Task Statement 2.1: Design scalable and loosely coupled architectures.
📘AWS Certified Solutions Architect – (SAA-C03)
1. What Is an Event-Driven Architecture?
An Event-Driven Architecture (EDA) is a design pattern where services communicate by sending and receiving events.
An event is simply a notification that something happened.
In IT systems, examples of events include:
- A file was uploaded to storage
- A user signed up
- A payment was completed
- A database record was updated
- A server error occurred
Instead of one service directly calling another service, it publishes an event, and other services can respond to it independently.
This creates:
- ✅ Loose coupling
- ✅ High scalability
- ✅ Better fault tolerance
- ✅ Asynchronous processing
These are all important for the SAA-C03 exam.
2. Why Event-Driven Architecture Is Important for the Exam
The SAA-C03 exam focuses heavily on:
- Designing scalable systems
- Building loosely coupled architectures
- Improving fault tolerance
- Supporting asynchronous processing
- Reducing system dependencies
Event-driven architecture helps achieve all of these.
You must understand:
- When to use events
- Which AWS services support events
- How events improve scalability
- How to choose the correct messaging service
3. Core Concepts You Must Know
3.1 Event Producer
The producer generates the event.
Examples in AWS:
- Amazon S3 (file upload event)
- Amazon DynamoDB (data change event)
- Amazon EC2 (instance state change)
The producer does NOT know who consumes the event.
3.2 Event Consumer
The consumer processes the event.
Examples:
- AWS Lambda
- Amazon EC2
- Amazon ECS
- AWS Step Functions
Consumers automatically react when an event occurs.
3.3 Event Router / Event Bus
An event bus receives events and routes them to the correct consumers.
AWS service for this:
- Amazon EventBridge
EventBridge can:
- Filter events
- Route to multiple targets
- Transform events
- Connect SaaS applications
- Schedule events
Exam tip:
If the question mentions event routing with filtering, think EventBridge.
4. Key AWS Services Used in Event-Driven Architectures
You must clearly understand the differences between these services.
4.1 Amazon SNS (Simple Notification Service)
Purpose:
Pub/Sub (publish/subscribe) messaging.
Characteristics:
- Push-based delivery
- Multiple subscribers
- Real-time fan-out
- At-least-once delivery
Subscribers can be:
- Lambda
- SQS
- HTTP endpoints
- SMS
Use SNS when:
- You need to send the same message to multiple systems
- You need immediate push notifications
- You need fan-out pattern
Exam keyword: Fan-out architecture
4.2 Amazon SQS (Simple Queue Service)
Purpose:
Message queue for decoupling systems.
Characteristics:
- Pull-based
- Messages stored until processed
- Increases fault tolerance
- Supports buffering
- Prevents message loss
Two types:
Standard Queue
- Unlimited throughput
- At-least-once delivery
- Possible duplicates
- Best-effort ordering
FIFO Queue
- Exactly-once processing
- Strict ordering
- Lower throughput
Exam tips:
- Need strict order? → FIFO
- Need maximum scalability? → Standard
4.3 Amazon EventBridge
Purpose:
Advanced event routing.
Key Features:
- Event filtering
- Content-based routing
- Cross-account event sharing
- SaaS integration
- Scheduled events (cron)
Use EventBridge when:
- You need intelligent routing
- You need to integrate multiple AWS services
- You want to build modern serverless systems
4.4 AWS Lambda
Very important in event-driven systems.
Lambda:
- Runs automatically when an event occurs
- Scales automatically
- No server management
- Ideal for asynchronous workloads
Common event sources:
- S3
- SQS
- SNS
- EventBridge
- DynamoDB Streams
4.5 Amazon DynamoDB Streams
Captures changes in DynamoDB tables.
Used for:
- Triggering Lambda
- Data replication
- Real-time processing
Exam tip:
If the question mentions “react to database changes,” think DynamoDB Streams + Lambda.
5. Common Event-Driven Architecture Patterns
You must know these patterns for the exam.
5.1 Fan-Out Pattern
One event → multiple consumers.
Service used:
SNS
Example IT scenario:
A system writes an event that a new user account was created.
SNS sends it to:
- Billing system
- Logging system
- Analytics system
Each system processes independently.
5.2 Queue-Based Decoupling
Producer → SQS → Consumer
Why?
- Producer and consumer do not depend on each other
- If consumer fails, messages remain in queue
- Smooth traffic spikes
Exam keywords:
- Buffer traffic
- Prevent overload
- Decouple applications
5.3 Event Filtering
EventBridge can route events only if:
- Specific field matches
- Specific service generated event
- Specific event type
Used for:
- Microservices
- Complex routing logic
5.4 Asynchronous Processing
Instead of waiting for response:
- System sends event
- Processing happens in background
Improves:
- Performance
- User experience
- Scalability
If the exam says:
“System must not wait for processing” → Use asynchronous event-driven approach.
6. How Event-Driven Architecture Improves Scalability
EDA helps scale because:
- Services are independent
- You can scale consumers separately
- Queues absorb traffic spikes
- Lambda auto-scales
- No direct tight coupling
Example IT explanation:
If 10,000 events arrive:
- SQS stores them
- Multiple Lambda functions process them in parallel
- System does not crash
This is horizontal scaling.
7. How Event-Driven Architecture Improves Fault Tolerance
Important exam concept.
If a consumer fails:
- Messages stay in SQS
- Retry mechanism processes later
- Dead-letter queues (DLQ) capture failed messages
Services that support DLQ:
- SQS
- SNS
- Lambda
Dead-letter queue = Stores messages that failed processing multiple times.
Exam keyword:
“Capture failed messages for later analysis” → Use DLQ.
8. Designing Loosely Coupled Systems (Very Important)
Loose coupling means:
- Services do not directly depend on each other.
- One service failure does not break the entire system.
- You can modify one service without affecting others.
Direct API call = Tight coupling
Event via queue = Loose coupling
For the exam:
If the question says:
- “Reduce dependencies”
- “Improve maintainability”
- “Improve scalability”
- “Decouple components”
Answer usually involves:
- SQS
- SNS
- EventBridge
- Lambda
9. Comparing SNS vs SQS vs EventBridge (Exam Critical)
| Feature | SNS | SQS | EventBridge |
|---|---|---|---|
| Messaging Type | Pub/Sub | Queue | Event Bus |
| Push or Pull | Push | Pull | Push |
| Fan-out | Yes | No | Yes |
| Message Storage | No | Yes | No |
| Filtering | Limited | No | Advanced |
| Best Use | Broadcast | Decoupling | Event routing |
Remember:
- Need buffering → SQS
- Need broadcast → SNS
- Need filtering & routing → EventBridge
10. When to Use Event-Driven Architecture
Use EDA when:
- Systems must scale independently
- You need asynchronous processing
- You want microservices architecture
- You need to integrate multiple AWS services
- You want fault tolerance
- You want to avoid tight coupling
Avoid EDA when:
- Immediate synchronous response required
- Simple small systems
11. Common Exam Scenarios
If question says:
“Application must process large number of background tasks without losing messages.”
Answer:
SQS + Lambda
“If multiple systems must be notified when an event happens.”
Answer:
SNS
“If events must be routed based on content.”
Answer:
EventBridge
“If database changes should trigger processing.”
Answer:
DynamoDB Streams + Lambda
“If failed messages must be stored for debugging.”
Answer:
Dead-letter queue
12. Important Terms to Remember
- Event
- Producer
- Consumer
- Event Bus
- Pub/Sub
- Asynchronous
- Fan-out
- Decoupling
- Dead-letter queue
- Idempotency (important for duplicate handling in SQS Standard)
Idempotency means:
Processing the same message multiple times does not create incorrect results.
Final Exam Strategy
For SAA-C03:
- Always look for keywords like:
- Decouple
- Scale independently
- High throughput
- Asynchronous
- Loose coupling
- Buffer traffic
- Identify:
- Is ordering required?
- Is exactly-once processing required?
- Is fan-out needed?
- Is advanced filtering required?
- Choose correct service:
- SNS → broadcast
- SQS → decoupling
- EventBridge → routing
- Lambda → serverless processing
Conclusion
Event-driven architecture is a core design principle for:
- Scalable systems
- Loosely coupled microservices
- Fault-tolerant applications
- Modern serverless architectures
For the SAA-C03 exam, you must clearly understand:
- How events work
- Differences between SNS, SQS, and EventBridge
- When to use FIFO vs Standard queues
- How Lambda integrates with events
- How dead-letter queues improve reliability
- How event-driven systems improve scalability and fault tolerance
Mastering this topic will significantly increase your chances of passing the exam.
