AWS Builder Center
Building a Scalable Event-Driven Order Processing System with Amazon EventBridge

Building a Scalable Event-Driven Order Processing System with Amazon EventBridge

Learn how to build a scalable, event-driven order processing system using Amazon EventBridge that decouples microservices and handles real-time e-commerce workflows. Includes complete implementation with Lambda functions, DynamoDB, and error handling patterns.

DataEngineer
Modern applications require real-time responsiveness and loose coupling between services. Traditional point-to-point integrations create brittle architectures that are difficult to scale and maintain. In this post, we'll explore how to build a robust, event-driven order processing system using Amazon EventBridge.

The Challenge with Traditional Order Processing

Traditional e-commerce order processing systems face several challenges:
  1. Tight Coupling: Services directly call each other, creating dependencies that make the system fragile.
  1. Scalability Issues: Point-to-point integrations don't scale well as new services are added.
  1. Error Handling Complexity: Managing failures across multiple synchronous service calls becomes increasingly complex.
  1. Limited Flexibility: Adding new business logic or integrations requires modifying existing code.

Enter Amazon EventBridge

Amazon EventBridge is a serverless event bus service that makes it easy to build event-driven applications. It provides:
  • Decoupled Architecture: Services communicate through events, not direct calls
  • Built-in Reliability: Automatic retries, dead letter queues, and error handling
  • Schema Registry: Centralized event schema management and validation
  • Flexible Routing: Route events to multiple targets based on content
  • Third-party Integrations: Connect to SaaS applications and AWS services

Solution Architecture

Our event-driven order processing system consists of:
  1. Order Service: Receives orders and publishes order events
  1. Inventory Service: Manages stock levels and reserves items
  1. Payment Service: Processes payments and handles billing
  1. Fulfillment Service: Manages shipping and delivery
  1. Notification Service: Sends customer updates via email/SMS
  1. Analytics Service: Tracks metrics and generates insights
All services communicate through EventBridge, creating a loosely coupled, scalable architecture.

Implementation Deep Dive

1. Event Schema Design

First, we define our event schemas for consistency and validation:
{

"OrderCreated": {
"type": "object",
"properties": {
"orderId": {"type": "string"},
"customerId": {"type": "string"},
"items": {
"type": "array",
"items": {
"type": "object",
"properties": {
"productId": {"type": "string"},
"quantity": {"type": "number"},
"price": {"type": "number"}
}
}
},
"totalAmount": {"type": "number"},
"timestamp": {"type": "string", "format": "date-time"}
}
}
}

2. Order Service Implementation

The order service receives HTTP requests and publishes events:
import json
import boto3
from datetime import datetime
from decimal import Decimal
eventbridge = boto3.client('eventbridge')

def create_order(event, context):

order_data = json.loads(event['body'])

# Generate order ID and add timestamp
order_id = generate_order_id()
order_data['orderId'] = order_id
order_data['timestamp'] = datetime.utcnow().isoformat()

# Publish OrderCreated event
response = eventbridge.put_events(
Entries=[
{
'Source': 'ecommerce.orders',
'DetailType': 'Order Created',
'Detail': json.dumps(order_data, default=str),
'EventBusName': 'order-processing-bus'
}
]
)

return {
'statusCode': 201,
'body': json.dumps({
'orderId': order_id,
'message': 'Order created successfully'
})
}

3. Inventory Service with Event Handling

The inventory service listens for order events and manages stock:
import json
import boto3
from boto3.dynamodb.conditions import Key
dynamodb = boto3.resource('dynamodb')
eventbridge = boto3.client('eventbridge')
inventory_table = dynamodb.Table('inventory')

def handle_order_created(event, context):

order_detail = event['detail']
order_id = order_detail['orderId']
items = order_detail['items']

try:
# Check and reserve inventory
reservation_results = []
for item in items:
result = reserve_inventory(item['productId'], item['quantity'])
reservation_results.append(result)

if all(result['success'] for result in reservation_results):
# Publish InventoryReserved event
publish_event('InventoryReserved', {
'orderId': order_id,
'reservations': reservation_results
})

else:
# Publish InventoryInsufficient event
publish_event('InventoryInsufficient', {
'orderId': order_id,
'failures': [r for r in reservation_results if not r['success']]
})

except Exception as e:
# Publish InventoryError event
publish_event('InventoryError', {
'orderId': order_id,
'error': str(e)
})

def reserve_inventory(product_id, quantity):

try:
response = inventory_table.update_item(
Key={'productId': product_id},
UpdateExpression='SET available = available - :qty, reserved = reserved + :qty',
ConditionExpression='available >= :qty',
ExpressionAttributeValues={':qty': quantity},
ReturnValues='UPDATED_NEW'
)

return {'success': True, 'productId': product_id, 'quantity': quantity}
except Exception:
return {'success': False, 'productId': product_id, 'reason': 'Insufficient stock'}

4. Event Rules and Routing

EventBridge rules determine which events go to which services:
# Rule for inventory service

{
"Name": "OrderToInventory",
"EventPattern": {
"source": ["ecommerce.orders"],
"detail-type": ["Order Created"]
},

"Targets": [
{
"Id": "InventoryLambda",
"Arn": "arn:aws:lambda:region:account:function:inventory-handler"
}
]
}

# Rule for payment service

{
"Name": "InventoryToPayment",
"EventPattern": {
"source": ["ecommerce.inventory"],
"detail-type": ["Inventory Reserved"]
},
"Targets": [
{
"Id": "PaymentLambda",
"Arn": "arn:aws:lambda:region:account:function:payment-handler"
}
]
}

5. Error Handling and Dead Letter Queues

EventBridge provides built-in error handling:
def configure_dlq_and_retry():

return {
"RetryPolicy": {
"MaximumRetryAttempts": 3,
"MaximumEventAge": 3600
},

"DeadLetterConfig": {
"Arn": "arn:aws:sqs:region:account:order-processing-dlq"
}
}

Real-World Use Case: E-commerce Platform

Let's consider how this architecture handles a typical order flow:

Order Processing Flow

  1. Customer Places Order: Order service receives HTTP request and publishes OrderCreated event
  1. Inventory Check: Inventory service receives event, checks stock, and publishes either InventoryReserved or InventoryInsufficient
  1. Payment Processing: Payment service processes payment when inventory is reserved, publishes PaymentProcessed or PaymentFailed
  1. Fulfillment: Fulfillment service creates shipping label and publishes OrderShipped
  1. Notifications: Notification service sends updates at each step
  1. Analytics: Analytics service tracks all events for business intelligence

Handling Failures

The event-driven architecture gracefully handles failures:
  • Inventory Shortage: System publishes InventoryInsufficient, triggering customer notification and order cancellation
  • Payment Failure: System releases reserved inventory and notifies customer
  • Service Downtime: EventBridge retries failed events and routes to dead letter queues

Performance and Cost Benefits

Performance Advantages

  1. Asynchronous Processing: Services don't wait for downstream operations
  1. Parallel Execution: Multiple services can process the same event simultaneously
  1. Auto Scaling: Each service scales independently based on event volume

Cost Efficiency

For a typical e-commerce platform processing 100,000 orders per month:
  • EventBridge: ~$10/month (100K events + rules)
  • Lambda: ~$25/month (execution time)
  • DynamoDB: ~$15/month (read/write operations)
  • Total: ~$50/month vs. $200+ for traditional server-based architecture

Monitoring and Observability

EventBridge integrates with AWS observability services:
# CloudWatch custom metrics

def publish_metrics(metric_name, value, unit='Count'):
cloudwatch = boto3.client('cloudwatch')
cloudwatch.put_metric_data(
Namespace='OrderProcessing',
MetricData=[
{
'MetricName': metric_name,
'Value': value,
'Unit': unit,
'Dimensions': [
{
'Name': 'Environment',
'Value': 'production'
}
]
}
]
)

Benefits and Limitations

Key Benefits

  1. Loose Coupling: Services can evolve independently
  1. Scalability: Each component scales based on demand
  1. Reliability: Built-in retry and error handling
  1. Flexibility: Easy to add new services and integrations
  1. Cost Effective: Pay only for events processed

Considerations

  1. Eventual Consistency: Events are processed asynchronously
  1. Debugging Complexity: Distributed tracing becomes important
  1. Event Ordering: EventBridge doesn't guarantee order
  1. Schema Evolution: Changes require careful versioning
The complete implementation, including Infrastructure as Code templates and deployment scripts, is available in my  GitHub  repo.

Conclusion

Amazon EventBridge enables building truly scalable, resilient event-driven architectures. By decoupling services through events, we create systems that are easier to maintain, scale, and extend.
Whether you're building an e-commerce platform, IoT data processing pipeline, or microservices architecture, EventBridge provides the foundation for modern, event-driven applications.
What event-driven challenges are you facing? Share your experiences in the comments below!
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article