AWS SQS Explained: A Complete Beginner-to-Advanced Guide (With Examples)

Amazon Simple Queue Service (SQS) is one of the most powerful yet simplest AWS services for building distributed, decoupled, and scalable applications. Whether you are designing microservices, event-driven systems, or background job processing—SQS is the backbone that ensures reliability and smooth message flow.

In this blog, we will explore:

• What AWS SQS is
• Why SQS is needed
• Types of queues
• Architecture
• Features
• Real-world use cases
• Dead-letter queues
• Example code (Node.js +php+laravel)
  Best practices

📌 What is AWS SQS?

AWS SQS (Simple Queue Service) is a fully managed message queue that enables microservices and distributed systems to communicate asynchronously.

👉 You send a message → it stays in a queue → a worker/consumer processes it.

You don’t worry about:

• Server maintenance
• Scaling
• Failures
• Message loss

AWS handles everything automatically.

✨ Why Do We Need SQS?

Modern systems need to process tasks asynchronously to stay fast and efficient.

❌ Without SQS (Direct communication)

• Services are tightly coupled
• If one service fails, the entire application may fail
• Traffic spikes can overload systems
• Long-running tasks slow down UI responses

✅ With AWS SQS

• Components are loosely coupled
• No message is lost
• Traffic spikes are handled smoothly
• Systems remain scalable and fault-tolerant
• Workers process tasks in the background

📦 Types of SQS Queues

1. Standard Queue (High Throughput)

• Nearly unlimited messages per second
• Best-effort ordering (not guaranteed)
• Messages delivered at least once (duplicate possible)

Use Case: sending emails, logs, notifications, processing jobs

2. FIFO Queue (First-In-First-Out)

• Guaranteed order
• No duplicates
• Limited throughput (3,000 msgs/s)

Use Case: payment processing, order events, inventory updates

⚙️ AWS SQS Architecture (Simple Diagram)

Producer ---> SQS Queue ---> Consumer (Worker/App)

Add DLQ (Dead Letter Queue) for failed messages:

Producer ---> Main Queue ---> Consumer
                                |
                                v
                         DLQ (Failed Messages)

🔍 Important SQS Features

✔ Message Retention (1 min – 14 days)

✔ Visibility Timeout

Prevents other workers from processing the same message.
Default: 30 seconds
Example: Worker is processing → message becomes invisible → if worker fails → message reappears.

✔ Dead Letter Queue (DLQ)

Failed messages are moved after max retries.

✔ Long Polling (recommended)

Reduces cost by waiting until a message is available.

✔ Encryption (SSE)

Data secured using AWS KMS.

✔ Message Batching

Send/receive up to 10 messages at once.

🧩 Real-World Use Cases

🔵 EXAMPLE 1 — Basic Email Queue With SQS (Node.js)

A simple app sends an email request to SQS, worker processes it later.

Architecture

Frontend → API → SQS Queue → Worker → Send Email

1️⃣ Step 1: Install AWS SDK

npm install @aws-sdk/client-sqs nodemailer

2️⃣ Step 2: Send Message (Producer)

import { SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";

const client = new SQSClient({ region: "ap-south-1" });

export const queueEmail = async () => {
  const params = {
    QueueUrl: process.env.SQS_URL,
    MessageBody: JSON.stringify({
      to: "user@example.com",
      subject: "Welcome to our platform!",
      timestamp: Date.now(),
    }),
  };

  await client.send(new SendMessageCommand(params));
  console.log("Message added to queue!");
};

3️⃣ Step 3: Worker to Receive & Process Message

import { SQSClient, ReceiveMessageCommand, DeleteMessageCommand } from "@aws-sdk/client-sqs";
import nodemailer from "nodemailer";

const sqs = new SQSClient({ region: "ap-south-1" });

async function processQueue() {
  while (true) {
    const data = await sqs.send(
      new ReceiveMessageCommand({
        QueueUrl: process.env.SQS_URL,
        MaxNumberOfMessages: 1,
        WaitTimeSeconds: 20, // Long polling
      })
    );

    if (!data.Messages) continue;

    for (const msg of data.Messages) {
      const payload = JSON.parse(msg.Body);
      console.log("Processing email:", payload.to);

      await sendEmail(payload);

      await sqs.send(
        new DeleteMessageCommand({
          QueueUrl: process.env.SQS_URL,
          ReceiptHandle: msg.ReceiptHandle,
        })
      );
    }
  }
}

async function sendEmail(data) {
  console.log("Email sent to:", data.to);
}

processQueue();

🔵 EXAMPLE 2 — Order Processing With FIFO Queue (Node.js)

Ensures correct order of order events.

📌 FIFO Rules

• Queue name must end with .fifo
• Requires MessageGroupId
• Supports exactly-once processing

Architecture

Order Service → orders.fifo → Worker → Update Inventory → Update DB

Send Order Message (FIFO)

await client.send(
  new SendMessageCommand({
    QueueUrl: process.env.FIFO_SQS_URL,
    MessageBody: JSON.stringify({
      orderId: "ORD_10021",
      action: "ORDER_PLACED",
    }),
    MessageGroupId: "order-events",
    MessageDeduplicationId: Number(Date.now()).toString(),
  })
);

Why?

• MessageGroupId = all messages in FIFO group ordered
• DeduplicationId = avoids duplicates

Receive & Process FIFO Messages

const data = await client.send(
  new ReceiveMessageCommand({
    QueueUrl: process.env.FIFO_SQS_URL,
    MaxNumberOfMessages: 1,
    WaitTimeSeconds: 20,
  })
);

FIFO processes one group at a time, ensuring order.

🔵 EXAMPLE 3 — Full Video Processing Workflow (Laravel)

This is a real-world heavy-use scenario.

Architecture

User Uploads Video → API → SQS Queue → Worker → Compress → Store → Notify User

Send Video Job to SQS (Laravel)

$sqs = new SqsClient([
    'region' => env('AWS_DEFAULT_REGION'),
    'version' => 'latest',
]);

$sqs->sendMessage([
    'QueueUrl' => env('SQS_VIDEO_QUEUE'),
    'MessageBody' => json_encode([
        'user_id' => $user->id,
        'file_path' => $uploadedFile,
    ]),
]);

Worker Consuming SQS (Laravel)

public function handle()
{
    $client = new SqsClient([
        'region' => env('AWS_DEFAULT_REGION'),
        'version' => 'latest',
    ]);

    while (true) {
        $result = $client->receiveMessage([
            'QueueUrl' => env('SQS_VIDEO_QUEUE'),
            'MaxNumberOfMessages' => 1,
            'WaitTimeSeconds' => 20,
        ]);

        if (!empty($result->get('Messages'))) {
            foreach ($result->get('Messages') as $message) {
                $data = json_decode($message['Body'], true);

                $this->compressVideo($data['file_path']);

                $client->deleteMessage([
                    'QueueUrl' => env('SQS_VIDEO_QUEUE'),
                    'ReceiptHandle' => $message['ReceiptHandle'],
                ]);
            }
        }
    }
}

🔵 EXAMPLE 4 — AWS Lambda Trigger With SQS

Zero servers. Just a Lambda that self-scales.

Configure:

SQS Queue → Lambda Trigger → Process → Auto-delete

Lambda Example (Node.js)

exports.handler = async (event) => {
  for (const record of event.Records) {
    const message = JSON.parse(record.body);
    console.log("Processing:", message);
  }
};

SQS pushes messages in batches to Lambda.

🔵 EXAMPLE 5 — Dead Letter Queue (DLQ) in Real Use

Scenario:

• Worker fails 5 times
• Message moves automatically to DLQ

Create Redrive Policy

maxReceiveCount = 5
deadLetterTargetArn = arn:aws:sqs: region:account:myDLQ

Worker Fails Example

try {
  throw new Error("Database Timeout");
} catch (err) {
  console.log("Failed:", err.message);
  // SQS will retry automatically until maxReceiveCount
}

Once retries exceed 5 → SQS moves it to DLQ.

🔵 EXAMPLE 6 — Batch Processing (10 Messages at Once)

Improves cost & performance.

Send Batch (Node.js)

await client.send(
  new SendMessageBatchCommand({
    QueueUrl: process.env.SQS_URL,
    Entries: [
      {
        Id: "1",
        MessageBody: "Task #1"
      },
      {
        Id: "2",
        MessageBody: "Task #2"
      }
    ]
  })
);

Receive Batch

const data = await sqs.send(
  new ReceiveMessageCommand({
    QueueUrl: process.env.SQS_URL,
    MaxNumberOfMessages: 10,
    WaitTimeSeconds: 20,
  })
);

🔵 EXAMPLE 7 — Visibility Timeout Failure Scenario

Step-by-step:

1. Worker receives message
2. Visibility timeout = 30 sec
3. Worker takes 90 sec → FAIL
4. Message reappears → another worker picks it
5. Duplicate processing occurs

Fix: Extend Visibility Timeout

await sqs.send(
  new ChangeMessageVisibilityCommand({
    QueueUrl: process.env.SQS_URL,
    ReceiptHandle: msg.ReceiptHandle,
    VisibilityTimeout: 120, // increase time
  })
);

Best Practices

✔ Enable long polling

✔ Use DLQ for all queues

✔ Use FIFO queues for ordered tasks

✔ Set correct visibility timeout

✔ Monitor SQS using CloudWatch

✔ Batch messages to reduce cost

✔ Encrypt messages with KMS

Conclusion

AWS SQS is a highly scalable, fault-tolerant, distributed queuing system that allows modern apps to run smoothly without losing messages. Whether building microservices, background jobs, or large asynchronous systems—SQS is a must-use AWS service.