Event-driven architecture patterns in DynamoDB - Step-by-Step Execution

Concept Flow - Event-driven architecture patterns

Event Occurs

↓

Event Captured by Producer

↓

Event Sent to Event Bus or Stream

↓

Event Consumed by One or More Consumers

↓

Consumers Process Event and Update DynamoDB Tables

↓

Optional: Trigger Further Events

Events happen and are sent to a stream or bus. Consumers listen and react by updating DynamoDB or triggering more events.

Execution Sample

DynamoDB

1. Event: New Order Created
2. Producer sends event to DynamoDB Stream
3. Consumer Lambda triggered by stream
4. Lambda updates Order Status in DynamoDB
5. Lambda triggers Shipment Event

Shows how an order creation event flows through DynamoDB Streams to update tables and trigger next steps.

Execution Table

Step	Action	Event/Data	Result/Effect
1	Order Created	{orderId: 123, status: 'NEW'}	Event generated
2	Event sent to DynamoDB Stream	Order Created Event	Stream records event
3	Consumer Lambda triggered	Reads event from stream	Lambda invoked
4	Lambda updates DynamoDB	Updates order status to 'PROCESSING'	Order table updated
5	Lambda triggers Shipment Event	{orderId: 123, action: 'SHIP'}	New event created
6	Shipment Consumer triggered	Reads shipment event	Shipment process started
7	No more events	End of event chain	Execution stops

💡 No more events to process, event-driven flow ends

Variable Tracker

Variable	Start	After Step 1	After Step 4	After Step 5	Final
orderStatus	null	'NEW'	'PROCESSING'	'PROCESSING'	'PROCESSING'
eventQueue	empty	Order Created Event	Order Created Event	Shipment Event added	empty after processing

Key Moments - 3 Insights

Why does the consumer Lambda get triggered after the event is sent to the DynamoDB Stream?

Because DynamoDB Streams capture table changes as events, and the Lambda is configured to listen to these streams, triggering automatically when new events appear (see execution_table step 3).

How does the event-driven pattern help keep the system responsive?

Events allow different parts of the system to react independently and asynchronously, so updates happen as soon as events occur without waiting for other processes (see execution_table steps 4 and 5).

What happens if no consumer processes an event?

The event remains in the stream until processed or expires, but no updates happen in DynamoDB, so the system state does not change (implied by exit_note and variable_tracker).

Visual Quiz - 3 Questions

Look at the execution_table, what is the orderStatus after Step 4?

A 'PROCESSING'

B 'SHIPPED'

C 'NEW'

D null

💡 Hint

Check the variable_tracker column 'After Step 4' for orderStatus value.

At which step does the consumer Lambda get triggered?

A Step 2

B Step 3

C Step 5

D Step 6

💡 Hint

Look at execution_table step descriptions for Lambda trigger.

If the eventQueue remains empty after Step 5, what does that mean?

A Events are still waiting to be processed

B No events were created

C All events have been processed

D The system crashed

💡 Hint

Refer to variable_tracker for eventQueue final state.

Concept Snapshot

Event-driven architecture uses events to trigger actions asynchronously.
DynamoDB Streams capture changes as events.
Consumers (like Lambda) listen to streams and react.
This decouples components and improves responsiveness.
Events can trigger further events for workflows.

Full Transcript

Event-driven architecture in DynamoDB means when something changes, like a new order, that change creates an event. This event goes into a DynamoDB Stream. A consumer, such as a Lambda function, listens to this stream. When it sees the event, it runs and updates the database or triggers more events. This way, different parts of the system work independently but stay in sync by reacting to events. The execution table shows each step from order creation to shipment event. Variables like orderStatus change as events are processed. This pattern helps systems stay fast and flexible.

Practice

1. What is the main purpose of using DynamoDB Streams in an event-driven architecture?

easy

A. To capture and record changes in the DynamoDB table as events

B. To store backup copies of the DynamoDB table

C. To increase the read capacity of the DynamoDB table

D. To encrypt data stored in DynamoDB

Solution

1. Step 1: Understand DynamoDB Streams role

   DynamoDB Streams capture data modification events like inserts, updates, and deletes.

2. Step 2: Identify the purpose in event-driven architecture

   These captured events trigger other processes automatically, enabling real-time reactions.

3. Final Answer:

   To capture and record changes in the DynamoDB table as events -> Option A

4. Quick Check:

   DynamoDB Streams = capture changes [OK]

Hint: Streams capture table changes as events for triggers [OK]

Common Mistakes:

• Confusing Streams with backups
• Thinking Streams increase capacity
• Assuming Streams encrypt data

2. Which of the following is the correct way to enable DynamoDB Streams on a table using AWS CLI?

easy

A. aws dynamodb set-stream --table MyTable --enabled true

B. aws dynamodb enable-stream --table MyTable --type NEW_IMAGE

C. aws dynamodb create-stream --table-name MyTable --view-type KEYS_ONLY

D. aws dynamodb update-table --table-name MyTable --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES

Solution

1. Step 1: Recall AWS CLI command for enabling streams

   The correct command uses 'update-table' with '--stream-specification' to enable streams.

2. Step 2: Verify syntax and parameters

   aws dynamodb update-table --table-name MyTable --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES correctly sets StreamEnabled=true and specifies StreamViewType as NEW_AND_OLD_IMAGES.

3. Final Answer:

   aws dynamodb update-table --table-name MyTable --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES -> Option D

4. Quick Check:

   Enable streams = update-table + stream-specification [OK]

Hint: Use update-table with stream-specification to enable streams [OK]

Common Mistakes:

• Using non-existent commands like enable-stream
• Incorrect parameter names
• Confusing create-stream with enabling streams

3. Given a DynamoDB Stream enabled with StreamViewType=NEW_IMAGE, what will an AWS Lambda function receive when an item is updated?

medium

A. Only the keys of the updated item

B. The entire item before and after the update

C. Only the new version of the item after the update

D. No data, only a notification that an update occurred

Solution

1. Step 1: Understand StreamViewType NEW_IMAGE meaning

   NEW_IMAGE sends only the new version of the item after the change.

2. Step 2: Determine what Lambda receives on update

   Lambda gets the updated item data, not the old version or just keys.

3. Final Answer:

   Only the new version of the item after the update -> Option C

4. Quick Check:

   NEW_IMAGE = new item data only [OK]

Hint: NEW_IMAGE sends only updated item data to Lambda [OK]

Common Mistakes:

• Confusing NEW_IMAGE with NEW_AND_OLD_IMAGES
• Assuming keys only are sent
• Thinking Lambda gets no data

4. You wrote a Lambda function triggered by DynamoDB Streams but it never executes. What is the most likely cause?

medium

A. The DynamoDB table does not have Streams enabled

B. The Lambda function is not subscribed to the stream

C. The Lambda function code has syntax errors

D. The DynamoDB table has no data

Solution

1. Step 1: Check if Streams are enabled

   If Streams were not enabled, no events would be generated, but question implies setup.

2. Step 2: Verify Lambda subscription to the stream

   Without subscribing Lambda to the stream, it won't trigger on events.

3. Final Answer:

   The Lambda function is not subscribed to the stream -> Option B

4. Quick Check:

   Lambda must be subscribed to stream to trigger [OK]

Hint: Ensure Lambda is subscribed to DynamoDB Stream [OK]

Common Mistakes:

• Assuming syntax errors stop invocation
• Thinking empty table stops Lambda trigger
• Ignoring subscription setup

5. You want to build a real-time notification system using DynamoDB and Lambda. Which event-driven architecture pattern best fits this use case?

hard

A. Use DynamoDB Streams to capture changes and trigger Lambda to send notifications

B. Use periodic polling of DynamoDB to check for changes and send notifications

C. Use DynamoDB Global Tables to replicate data and notify users

D. Use DynamoDB backups to trigger notifications on data changes

Solution

1. Step 1: Identify real-time event-driven pattern

   Real-time notifications require immediate reaction to data changes.

2. Step 2: Match pattern with DynamoDB Streams and Lambda

   Streams capture changes as events; Lambda processes them instantly to notify users.

3. Final Answer:

   Use DynamoDB Streams to capture changes and trigger Lambda to send notifications -> Option A

4. Quick Check:

   Streams + Lambda = real-time notifications [OK]

Hint: Streams trigger Lambda for instant notifications [OK]

Common Mistakes:

• Choosing polling which is not real-time
• Confusing replication with notifications
• Using backups which are not event triggers