AWS Lambda Tutorial: Building a Real-Time Notification System

Real-World Problem: Keeping Users Informed with Real-Time Notifications

Modern applications rely heavily on notifications to keep users engaged. Whether it’s an e-commerce app sending order updates, a social media platform alerting about new messages, or a monitoring tool notifying about system errors, real-time notifications are crucial.

In this tutorial, we’ll use AWS Lambda to build a real-time notification system integrated with Amazon SNS (Simple Notification Service).

Why Use AWS Lambda for Notifications?

1. Event-Driven: Automatically trigger notifications based on specific events, such as database updates or API calls.
2. Serverless Scalability: Handle thousands of notification requests without managing infrastructure.
3. Low Latency: Ensure instant delivery of notifications to users.
4. Cross-Channel Support: Send notifications via SMS, email, or push notifications using SNS.

How the Solution Works

1. Event Source: A user places an order, generating an event in DynamoDB.
2. Trigger: The DynamoDB event invokes a Lambda function.
3. Notification Logic: Lambda processes the event and sends a notification via Amazon SNS.
4. Delivery: SNS delivers the notification to users via email, SMS, or mobile push.

Step-by-Step: Building the Real-Time Notification System

Step 1: Set Up DynamoDB for Event Tracking

1. Create a DynamoDB Table:
   • Go to AWS Management Console → DynamoDB → Create Table.
   • Name the table Orders with a partition key OrderID.
2. Add Sample Data: Insert a sample order item into DynamoDB

{
    “OrderID”: “12345”,
    “CustomerName”: “John Doe”,
    “OrderStatus”: “Processing”
}

Step 2: Configure Amazon SNS

1. Create an SNS Topic:
   • Navigate to Amazon SNS → Topics → Create Topic.
   • Name the topic OrderUpdates.
2. Add Subscriptions:
   • Add an Email Subscription:
     • Protocol: Email.
     • Endpoint: Your email address.
   • Add an SMS Subscription (Optional):
     • Protocol: SMS.
     • Endpoint: Your phone number.
3. Confirm Subscriptions:
   • Check your email or phone to confirm the subscriptions.

Step 3: Create the Lambda Function

1. Go to Lambda Console:
   • Create a new function named SendOrderNotifications.
   • Use Node.js 18.x as the runtime.
2. Attach IAM Permissions:
   • Attach the AmazonSNSFullAccess policy to allow Lambda to publish messages to SNS.
3. Write the Function Code: Add the following code to index.js:

const AWS = require(‘aws-sdk’);
const sns = new AWS.SNS();
exports.handler = async (event) => {
    try {
        console.log(‘Event received:’, JSON.stringify(event));
        // Extract order details from the DynamoDB event
        const orderDetails = event.Records[0].dynamodb.NewImage;
        const orderID = orderDetails.OrderID.S;
        const customerName = orderDetails.CustomerName.S;
        const orderStatus = orderDetails.OrderStatus.S;
        // Construct the notification message
        const message = `Hello ${customerName}, your order (#${orderID}) status is now: ${orderStatus}.`;
        // Publish the message to SNS
        const params = {
            Message: message,
            TopicArn: ‘arn:aws:sns:us-east-1:123456789012:OrderUpdates’
        };
        await sns.publish(params).promise();
        console.log(‘Notification sent successfully.’);
    } catch (error) {
        console.error(‘Error sending notification:’, error);
        throw error;
    }
};

Step 4: Add DynamoDB Trigger

1. Go to the DynamoDB Table → Triggers → Create Trigger.
2. Select your Lambda function (SendOrderNotifications) as the trigger.
3. Save the configuration.

Step 5: Test the System

1.Insert a New Order:
Add a new item to the Orders table in DynamoDB

{
    “OrderID”: “12346”,
    “CustomerName”: “Jane Doe”,
    “OrderStatus”: “Shipped”
}

2.Receive the Notification:
Check your email or SMS for a notification about the order status update.

Real-Life Use Cases

1. E-Commerce Platforms:
   • Send order confirmations, shipping updates, and delivery notifications.
2. Social Media Apps:
   • Notify users about friend requests, likes, or comments.
3. System Monitoring:
   • Alert teams about server errors or unusual activity in real time.

Pro Tips for AWS Lambda Notifications

1. Use Environment Variables:
   Store the SNS topic ARN in environment variables for easier configuration.
2. Filter DynamoDB Events:
   Use conditions to trigger notifications only for specific changes, like status updates.
3. Monitor Performance:
   Use AWS CloudWatch to track function invocations and detect any failures.
4. Retry Logic:
   Enable dead-letter queues to capture failed notifications for later processing.
5. Cost Optimization:
   Leverage AWS Free Tier for Lambda and SNS to minimize costs for low-usage scenarios.

Pricing Breakdown

1. AWS Lambda:
   • Free for the first 1 million requests. $0.20 per million requests after.
   • Compute time costs $0.00001667 per GB-second.
2. Amazon SNS:
   • $0.50 per million publishes.
   • $0.00645 per SMS in the US (email notifications are free).
3. DynamoDB:
   • Free for up to 25 GB of storage and 25 Write/Read Capacity Units.

Conclusion: Build Engaging Applications with Lambda

AWS Lambda’s event-driven architecture makes it ideal for real-time notification systems. By integrating with SNS, DynamoDB, and other AWS services, you can build a highly scalable, cost-effective notification system for your application.

Ready to engage your users like never before? Start building your Lambda-powered notification system today and deliver real-time updates with ease.