Arkinu
AWS service comparison

Amazon EventBridge vs Amazon SQS: differences and when to use each

Amazon EventBridge
Amazon SQS

Often confused on the examQuestions tend to offer one as a distractor for the other: look for the phrase in the scenario that tips the balance.

Application Integration

Amazon EventBridge

Serverless service that connects components using events: it receives events from AWS services, your own applications, and third-party software, filters and transforms them, and delivers them to the appropriate targets. It includes EventBridge Scheduler for scheduling tasks with cron or rate expressions.

Exam phrases that point here

  • «automatically react when an AWS resource changes state»

    Many AWS services send their events to the account's default event bus; a rule with an event pattern detects the change (for example, an EC2 instance moving to stopped) and triggers a target, with nothing for you to poll.

    When not: If the requirement is to find out who made an API call for auditing, the answer points to AWS CloudTrail; if the reaction depends on a metric crossing a threshold, an Amazon CloudWatch alarm is a better fit.

  • «route events to different targets based on their content»

    The rules on a classic bus (or the filters on each subscriber in the new Custom Event Bus) compare every event against a pattern on its fields and send only the matching ones to their target; a single event can reach several targets.

    When not: If the core requirement is to fan out the same message to a very large number of subscribers, including email, SMS, or mobile push notifications, Amazon SNS is usually a better fit; if messages must be held until a consumer pulls them at its own pace, the key component is usually Amazon SQS.

  • «receive events from a third-party SaaS application without writing polling code»

    SaaS partners integrated with EventBridge publish to a partner event source which, once associated with an event bus in your account, lets you apply rules to those events.

    When not: If the provider is not an EventBridge partner, another ingestion mechanism is needed; and if the requirement is to transfer data in bulk from a SaaS application to a destination such as Amazon S3, the answer points to Amazon AppFlow.

  • «run a task on a schedule without managing servers»

    EventBridge Scheduler (or, previously, scheduled rules) invokes an AWS target based on a cron, rate, or one-time expression, with configurable retries.

    When not: EventBridge only triggers the task: the target does the work. If the question is about where a long-running process runs, the answer lies in compute (for example, AWS Batch or Amazon ECS), not in the scheduler.

  • «reprocess past events after fixing a bug»

    On a classic bus, Archive and Replay stores events and resends them later. The new Custom Event Bus retains them for 1 to 365 days, and a subscriber can start reading from a point in the past. It is useful for debugging, recovering, or populating a new target.

    When not: If it is real-time streaming data (clicks, telemetry) that several applications process and reread, Amazon Kinesis Data Streams is usually a better fit. Note that ordering and rereading alone no longer rule out EventBridge, because the new Custom Event Bus retains events and delivers them in order per group.

  • «connect a source to a single target, with filtering and enrichment, without integration code»

    EventBridge Pipes connects a source (such as an SQS queue or a Kinesis or DynamoDB stream) to a target, with optional filtering and enrichment in between.

    When not: If there are many sources and many targets, the pattern is an event bus, not a pipe; and if it is enough for AWS Lambda to read from a queue, the Lambda event source mapping already solves it.

Often paired with

  • AWS Lambda
  • AWS Step Functions
  • Amazon SQS
Study Amazon EventBridge →

Application Integration

Amazon SQS

Managed message queue that stores messages until a consumer processes and deletes them, or until their retention period expires (14 days maximum). It is used to decouple the components of a distributed system and to absorb load spikes as a request buffer.

Exam phrases that point here

  • «decouple the application components»

    A queue sits between whoever produces the work and whoever processes it: the producer leaves the message and moves on, and the consumer picks it up when it can. If either one fails or slows down, the other does not notice.

    When not: If the same message must reach several targets at once, the pattern is publish/subscribe (Amazon SNS), and if you need to route events based on their content or react to events from AWS or third-party services, Amazon EventBridge is usually a better fit.

  • «absorb traffic spikes without losing requests»

    The queue stores the messages while the consumers cannot keep up, so the spike turns into a processing delay instead of lost requests.

    When not: It only works if the work can be done asynchronously. If the user needs the response right away, the solution is to scale the tier that responds (for example, with a load balancer and Auto Scaling), not to queue.

  • «process messages in the exact order they were sent and without duplicates»

    Amazon SQS FIFO queues preserve ordering within each message group and prevent processing the same message twice.

    When not: A standard queue guarantees neither ordering nor the absence of duplicates. And if several consumers must read the same data stream or reprocess it in real time, think of Amazon Kinesis Data Streams, not a queue.

  • «isolate messages that could not be processed so they can be analyzed later»

    A dead-letter queue receives the messages that consumers failed to process after several attempts, so they do not block the queue and can be reviewed.

    When not: If the scenario asks to retry or capture failures of an asynchronously invoked AWS Lambda function, or of an AWS Step Functions workflow, the answer may lie in that service's configuration and not in an SQS queue.

  • «each task must be processed by a single worker»

    In a queue, a received message is hidden from the other consumers for the duration of the visibility timeout; the worker that processes it deletes it when done.

    When not: If several systems must be notified of the task at once, each with its own copy, the clue points to Amazon SNS (often combined with several SQS queues).

Often paired with

  • AWS Lambda
  • Amazon SNS
Study Amazon SQS →