1.1 Create an AWS Account

If you don’t already have an AWS account, sign up at aws.amazon.com. New accounts receive 12 months of Free Tier access.

1.2 Create an IAM Role for Lambda

Your Lambda function needs appropriate permissions to execute and access other AWS resources. Here’s how to create an IAM role:

1. Navigate to the IAM console
2. Select “Roles” and click “Create role”
3. Choose “AWS service” as the trusted entity and “Lambda” as the use case
4. Attach these policies: AWSLambdaBasicExecutionRole (for CloudWatch Logs) and any other services your function needs to access
5. Name your role (e.g., “serverless-api-lambda-role”) and create it

1.3 IAM Role Configuration Screenshot

[IAM Role Configuration Screenshot with appropriate policy attachments]

2.1 Navigate to Lambda Console

Open the AWS Management Console and search for “Lambda” or find it under Services.

2.2 Create a New Function

• Click “Create function”
• Select “Author from scratch”
• Enter a function name (e.g., “serverless-api-function”)
• Choose runtime (e.g., Node.js 18.x, Python 3.11)
• Select the IAM role you created earlier
• Click “Create function”

2.3 Write Your Lambda Function Code

Here’s a simple Node.js example that returns a JSON response:

exports.handler = async (event) => {
    const response = {
        statusCode: 200,
        headers: {
            "Content-Type": "application/json",
            "Access-Control-Allow-Origin": "*"
        },
        body: JSON.stringify({
            message: "Hello from your Serverless API!",
            timestamp: new Date().toISOString(),
            path: event.path,
            method: event.httpMethod,
            queryParams: event.queryStringParameters || {}
        })
    };
    
    return response;
};

This function returns basic information about the request including timestamp, path, and query parameters.

3.1 Create a New API

1. Navigate to the API Gateway console
2. Click “Create API”
3. Choose “REST API” and click “Build”
4. Select “New API” and enter a name (e.g., “Serverless-API”)
5. Choose “Regional” for Endpoint Type
6. Click “Create API”

3.2 Create a Resource and Method

1. Click “Actions” and select “Create Resource”
2. Enter a Resource Name (e.g., “items”)
3. Click “Create Resource”
4. With your new resource selected, click “Actions” and select “Create Method”
5. Select “GET” from the dropdown and click the checkmark
6. Set Integration type to “Lambda Function”
7. Select your Lambda function region and enter your function name
8. Click “Save”

3.3 Deploy Your API

1. Click “Actions” and select “Deploy API”
2. For “Deployment stage”, select “New Stage”
3. Enter a stage name (e.g., “dev”, “prod”)
4. Add a description (optional)
5. Click “Deploy”

After deployment, you’ll see your API’s Invoke URL. This is the endpoint you’ll use to access your API.

4.1 Test in API Gateway Console

1. In the API Gateway console, navigate to your API
2. Select the resource and method you created
3. Click the “Test” button
4. Configure any query parameters or request body (if needed)
5. Click “Test” to execute the request

You should see the response from your Lambda function in the console.

4.2 Test with cURL

curl -X GET "https://your-api-id.execute-api.region.amazonaws.com/stage/items" -H "Content-Type: application/json"

4.3 Test with Postman

1. Open Postman and create a new request
2. Set the request type to GET
3. Enter your API’s Invoke URL followed by your resource path (e.g., https://your-api-id.execute-api.region.amazonaws.com/stage/items)
4. Add any headers or query parameters needed
5. Click “Send” to execute the request

[Postman API Test Screenshot showing successful response]

// In your Lambda function
if (event.httpMethod === 'GET') {
    // Logic to retrieve data
    const itemId = event.pathParameters?.id;
    // Fetch item from database
    return {
        statusCode: 200,
        body: JSON.stringify({ /* item data */ })
    };
}

// In your Lambda function
if (event.httpMethod === 'POST') {
    // Logic to create data
    const requestBody = JSON.parse(event.body);
    // Insert into database
    return {
        statusCode: 201,
        body: JSON.stringify({ id: 'new-id', ...requestBody })
    };
}

// In your Lambda function
if (event.httpMethod === 'PUT') {
    // Logic to update data
    const itemId = event.pathParameters?.id;
    const requestBody = JSON.parse(event.body);
    // Update in database
    return {
        statusCode: 200,
        body: JSON.stringify({ id: itemId, ...requestBody })
    };
}

// In your Lambda function
if (event.httpMethod === 'DELETE') {
    // Logic to delete data
    const itemId = event.pathParameters?.id;
    // Delete from database
    return {
        statusCode: 204,
        body: JSON.stringify({ message: 'Item deleted successfully' })
    };
}

DynamoDB (NoSQL)

Perfect for serverless applications due to its scalability and pay-per-request pricing.

const AWS = require('aws-sdk');
const dynamoDB = new AWS.DynamoDB.DocumentClient();

// Example: Get item from DynamoDB
const params = {
    TableName: 'YourTableName',
    Key: {
        id: 'item-id'
    }
};

const data = await dynamoDB.get(params).promise();

RDS (Relational)

For applications requiring complex queries and transactions.

const mysql = require('mysql2/promise');

// Create connection pool
const pool = mysql.createPool({
    host: process.env.DB_HOST,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME
});

// Example: Query database
const [rows] = await pool.query(
    'SELECT * FROM items WHERE id = ?', 
    [itemId]
);

1. Provisioned Concurrency

Pre-initialize a set number of execution environments to eliminate cold starts for predictable traffic patterns.

2. Code Optimization

• Minimize dependencies to reduce package size
• Use module bundlers like webpack to eliminate unused code
• Move SDK initialization outside the handler function

3. Scheduled Warming

Create a CloudWatch Events rule to periodically invoke your function to keep containers warm.

4. Memory Allocation

Allocate more memory to your function (which also increases CPU allocation) to reduce initialization and execution time.

CloudWatch Logs

CloudWatch Logs are your primary debugging tool for Lambda functions:

1. Navigate to the CloudWatch console
2. Select “Log groups”
3. Find your Lambda function’s log group (/aws/lambda/your-function-name)
4. Examine the latest log stream for errors and debug information

Add detailed logging to your function:

console.log('Processing event:', JSON.stringify(event));
console.log('Database response:', JSON.stringify(dbResponse));
console.error('Error occurred:', error.message);

API Gateway Test Console

The API Gateway console provides a testing feature to debug your API without external tools:

1. Navigate to the API Gateway console
2. Select your API and stage
3. Select the method you want to test
4. Click the “Test” button
5. Configure test request parameters and body
6. Review the execution logs and response

This tool shows the complete request-response cycle, including any mapping templates and authorizers.

FinTech Startup: RapidLoan

RapidLoan built a loan application processing API using AWS Lambda and API Gateway that handles 50,000+ requests daily with variable traffic patterns.

Key Results:

• Reduced infrastructure costs by 70% compared to traditional server setup
• Scaled automatically during marketing campaigns without performance degradation
• Processed applications in under 3 seconds, down from 15 seconds previously
• Eliminated monthly server maintenance tasks, saving 20+ engineering hours per week

Architecture Highlights: Used DynamoDB for application storage, Step Functions for loan approval workflow, and Lambda functions for credit scoring algorithms.

Healthcare Tech: PatientConnect

PatientConnect developed a HIPAA-compliant patient data API that securely connects medical devices to their platform.

Key Results:

• Achieved 99.99% uptime while handling 10M+ daily data points
• Reduced time-to-market by 4 months compared to traditional architecture
• Cut development team size from 6 to 3 engineers
• Maintained HIPAA compliance with end-to-end encryption

Architecture Highlights: Implemented API Gateway with custom authorizers for authentication, Lambda for data processing, and encrypted S3 storage with lifecycle policies.

E-commerce Platform: ShopQuick

ShopQuick built their product catalog and inventory management API using serverless architecture to handle seasonal traffic spikes.

Key Results:

• Seamlessly handled 20x traffic increase during Black Friday sales
• Reduced average API response time from 250ms to 75ms
• Cut monthly infrastructure costs by 65%
• Implemented real-time inventory updates across multiple sales channels

Architecture Highlights: Used Lambda functions with DynamoDB streams for inventory updates, API Gateway with caching for product catalog, and EventBridge for inter-service communication.

Authentication and Authorization

Protect your API from unauthorized access with these methods:

• API Keys: Simple token-based authentication suitable for internal or partner APIs
• AWS Cognito: Provides user pools and identity management for web and mobile applications
• Custom Lambda Authorizers: Execute Lambda functions to validate tokens or implement custom auth logic
• IAM Roles: Use AWS Identity and Access Management for internal service-to-service communication

exports.handler = async (event) => {
    const token = event.authorizationToken;
    
    // Validate token (e.g., JWT verification)
    try {
        const decodedToken = verifyToken(token);
        
        // Generate AWS policy
        return generatePolicy(
            decodedToken.sub,
            'Allow',
            event.methodArn
        );
    } catch (error) {
        return generatePolicy(
            'user',
            'Deny',
            event.methodArn
        );
    }
};

function generatePolicy(principalId, effect, resource) {
    return {
        principalId,
        policyDocument: {
            Version: '2012-10-17',
            Statement: [{
                Effect: effect,
                Action: 'execute-api:Invoke',
                Resource: resource
            }]
        }
    };
}

Data Protection

Secure your data at rest and in transit:

• Encryption in Transit: Enable HTTPS for all API Gateway endpoints
• Encryption at Rest: Use AWS KMS to encrypt sensitive data in databases and storage
• Input Validation: Implement request validation in API Gateway using JSON Schema
• Output Filtering: Filter sensitive information before returning API responses

{
  "definitions": {},
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["name", "email"],
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1
    },
    "email": {
      "type": "string",
      "format": "email"
    },
    "age": {
      "type": "integer",
      "minimum": 0,
      "maximum": 120
    }
  }
}

CloudWatch Metrics and Alarms

Key metrics to monitor:

• Invocation Count: Track API usage patterns
• Error Rate: Monitor failures and exceptions
• Latency: Track response times (p50, p90, p99)
• Throttling: Identify when concurrent execution limits are reached
• Memory Utilization: Optimize memory allocation

Set up CloudWatch Alarms to notify you when metrics exceed thresholds:

# AWS CLI example to create an alarm for high error rates
aws cloudwatch put-metric-alarm \
  --alarm-name "High-Error-Rate" \
  --alarm-description "Alarm when error rate exceeds 5%" \
  --metric-name Errors \
  --namespace AWS/Lambda \
  --statistic Sum \
  --dimensions Name=FunctionName,Value=your-function-name \
  --period 300 \
  --evaluation-periods 1 \
  --threshold 5 \
  --comparison-operator GreaterThanThreshold \
  --alarm-actions arn:aws:sns:region:account-id:topic-name

Distributed Tracing with X-Ray

AWS X-Ray helps you trace requests as they flow through your serverless architecture:

1. Enable X-Ray tracing for your Lambda function and API Gateway
2. Add the AWS X-Ray SDK to your Lambda code
3. Use subsegments to track specific operations in your code

// Node.js example with X-Ray tracing
const AWSXRay = require('aws-xray-sdk');
const AWS = AWSXRay.captureAWS(require('aws-sdk'));

exports.handler = async (event) => {
    // Create a custom subsegment
    const subsegment = AWSXRay.getSegment().addNewSubsegment('DatabaseQuery');
    
    try {
        const dynamoDB = new AWS.DynamoDB.DocumentClient();
        const result = await dynamoDB.get({
            TableName: 'YourTable',
            Key: { id: 'item-id' }
        }).promise();
        
        subsegment.addAnnotation('ItemRetrieved', 'Success');
        subsegment.close();
        
        return {
            statusCode: 200,
            body: JSON.stringify(result.Item)
        };
    } catch (error) {
        subsegment.addError(error);
        subsegment.close();
        throw error;
    }
};