What is an event-driven architecture?

Traditional approaches to integrating applications involve tightly coupling them together, making changes to one system impact the other.

Event-driven architecture is an excellent way to decouples and aggregate two or more applications because it provides a flexible and scalable way to integrate and communicate between different systems sources, such as user actions, system events, or sensor data. Event-driven architectures are used to build complex and scalable systems that respond to changes in real-time.

In this article, we will explore how to use SNS, SQS, and Lambda to build a robust and scalable event-driven architecture on AWS, and why event-driven architecture is a good for aggregating two applications.

Event-Driven Architecture on AWS

AWS provides several services that can be used to build an event-driven architecture, including SNS, SQS, and Lambda. Let’s take a look at how to use each of these services.

SNS is a messaging service that enables you to send notifications to a variety of endpoints, including email, SMS, and HTTP endpoints. SNS is a powerful tool that can be used to publish and subscribe to events in real-time. To use SNS in your event-driven system, you can create a topic and define subscriptions for the topic. Subscriptions can be email, SMS, HTTP endpoints, or AWS Lambda functions. When an event occurs, SNS publishes the event to the topic, and all subscribers are notified.

SQS is a messaging service that enables you to decouple and scale microservices, distributed systems, and serverless applications. SQS is a powerful tool that can be used to reliably and asynchronously process events. To use SQS in your event-driven system, you can create a queue and define a message consumer, which can be an AWS Lambda function. When an event occurs, you can publish the event to the SQS queue. The message consumer then processes the event asynchronously, which enables you to decouple the event producer from the event consumer.

Lambda is a serverless compute service that enables you to run code without provisioning or managing servers. You can create a Lambda function and define an event source, which can be an SNS topic or an SQS queue. When an event occurs, Lambda processes the event and triggers the associated function. Lambda enables you to process events in real-time without having to manage servers, which makes it an ideal tool for building scalable and cost-effective event-driven systems.

Here is an example of how you can use these services to process events in real-time:

Define an SNS topic for the events you want to capture, and subscribe the SQS queue to the SNS topic, finally configure the Lambda function to consume messages from the SQS queue.

Publish events to the SNS topic, which will finally trigger the Lambda function.

This architecture enables you to process events in real-time, without having to manage servers or worry about scaling. You can also use other AWS services, such as CloudWatch, to monitor and manage your event-driven system.

How to take care about the failed process?

In an event-driven system, it is important to ensure that all events are processed correctly. However, there may be situations where an event fails to be processed, due to errors in the processing logic or other issues.

In such cases, it is important to ensure that the failed event is captured and processed correctly. One way to achieve this is by using a dead-letter queue (DLQ).

A dead-letter queue is a type of message queue that captures messages that cannot be processed. In an event-driven system, a DLQ can be used to capture failed events that could not be processed. This ensures that the failed event is not lost and can be reprocessed at a later time.

Here’s how you can use a DLQ in an event-driven system:

Create a DLQ: Create an SQS queue that will be used as the DLQ for your event-driven system.

Configure your processing function: Configure your processing function (e.g., an AWS Lambda function) to send any failed events to the DLQ. This can be achieved by setting the “Dead Letter Queue” attribute to the ARN (Amazon Resource Name) of the DLQ.

Define your retry policy: Define a retry policy for failed events that have been sent to the DLQ. This can be done by setting the “Maximum Receives” attribute of the DLQ. This attribute specifies the number of times a message can be received from the DLQ before it is considered to be “dead”.

Process messages from the DLQ:

Create a separate processing function that reads messages from the DLQ and reprocesses them. This function can be triggered manually or automatically using a CloudWatch Event rule.

By using a DLQ in your event-driven system, you can ensure that failed events are captured and processed correctly. This can help to improve the reliability and resilience of your system, and ensure that all events are processed in a timely and efficient manner.

Why event-driven architecture is a good choice for aggregating two applications

Here are some of the main reasons why event-driven architecture is a good choice for aggregating two applications:

Decoupling: SNS and SQS act as intermediaries between the different applications, decoupling them from each other. Each application can produce and consume events independently without needing to know about each other’s implementation details. This allows each application to evolve independently without affecting the others, providing a flexible and adaptable integration between systems.

Scalability: SNS and SQS are designed to handle high throughput and scale as the volume of messages increases, making them ideal for aggregating multiple applications. The use of Lambda further enhances this scalability, by allowing each message to trigger the execution of code in a distributed and parallel manner, ensuring that each system can handle the workload.

Fault tolerance: Event-driven architecture is designed to handle faults and failures gracefully. By using SQS as a buffer, messages can be stored temporarily until the receiving application is available. This prevents message loss, providing a reliable and fault-tolerant way of integrating applications.

Flexibility: The use of Lambda as a processing service provides a high level of flexibility, allowing you to implement custom business logic, data transformation, and processing for each application. This makes it easy to integrate with different types of systems, protocols, and data formats.

Cost-effective: Since Lambda executes code only when a message is received, it is highly cost-effective, with pricing based on the number of requests and execution time. This means that you only pay for what you use, making it an efficient and cost-effective way of integrating applications.


In summary, the use of event-driven architecture using SNS, SQS, and Lambda provides a flexible, scalable, fault-tolerant, and cost-effective way to integrate two or more applications. By decoupling systems, using scalable and fault-tolerant messaging, and executing custom business logic in a distributed and parallel manner, you can create an efficient and adaptable integration between systems that can evolve independently and provide a better overall user experience.