Build a Serverless Task Tracker API

Introduction

30 Second Summary

Every time you add a task to a to-do app, something behind the scenes receives your request, processes it, and stores it for later. Most modern apps handle this without a dedicated server running around the clock.

In this project, you will build a serverless Task Tracker API on AWS that can create tasks, retrieve them by ID, and list all tasks. You will deploy it as a live, publicly accessible endpoint that you can demonstrate in interviews.

What You'll Build

A serverless REST API using API Gateway, Lambda, and DynamoDB that handles task creation, retrieval, and listing through HTTP requests.

By the end of this project, you'll have:

• A DynamoDB table storing task records with unique IDs and timestamps.
• Three Python Lambda functions implementing create, get, and list operations for your tasks.
• A live, publicly accessible REST API endpoint deployed through API Gateway that you can call from anywhere.
• Secret Mission: Add a delete endpoint and implement task status updates to mark tasks as complete.

Are there any prerequisites?

None. This project includes setup for everything you need. All you need is a web browser and an email address to create your free AWS account.

Create Your AWS Account

Every service you'll use in this project lives in the AWS cloud. To access them, you need an AWS account with Free Tier access.

In this step, you'll create a free AWS account, sign in to the Management Console, and set your region so all your resources are created in one place.

In this step, get ready to:

• Create an AWS Free Tier account.
• Sign in to the AWS Management Console.
• Set your console region.

Sign up for AWS Free Tier

• Open your web browser and navigate to https://aws.amazon.com/free/.
• Click Create a free account.
• Enter your email address in the Root user email address field.
• Enter a name for your account in the AWS account name field.
• Click Verify email address and check your inbox for a verification code.
• Enter the verification code and create a strong password.
• Choose Personal as the account type.
• Enter your contact information and accept the AWS Customer Agreement.
• Enter a payment method when prompted.
• Complete phone verification by entering the PIN from the automated call or text.
• Select the Basic support - Free plan.
• Choose Complete sign up.
• During the signup process, select the Free plan when asked to choose between Free and Paid.

Will I be charged?

No. The Free plan gives you $100 in credits immediately, plus up to $100 more by completing onboarding tasks. You will not be charged unless you upgrade to a Paid plan.

AWS requires a payment method to verify your identity and prevent fraud. The card is only billed if you exceed Free Tier usage limits, which is virtually impossible for this project.

Not receiving the verification email?

Check your spam or junk folder. The email comes from an address ending in @verify.signin.aws. Account activation usually takes a few minutes but can sometimes take up to 24 hours.

help me troubleshoot AWS account verification

Sign in to the AWS Management Console

• Once you receive the activation confirmation email, navigate to https://console.aws.amazon.com/.
• Select Root user.
• Enter the email address you used during signup in the Root user email address field.
• Click Next.
• Enter your password and click Sign in.
• You'll land on the Console Home page.
• In the search bar at the top of the page, type DynamoDB and confirm that the service appears in the results.

Seeing DynamoDB in the search results confirms your account is fully activated and you can access AWS services.

What is the AWS Free Tier?

The Free plan lets you experiment with AWS services at no cost for up to 6 months. The services we use in this project (Lambda, API Gateway, DynamoDB) are all Always Free within their monthly limits.

Always Free means these services remain free forever (not just 6 months) as long as you stay under 1M Lambda requests/month, 1M API Gateway calls/month, and 25 GB DynamoDB storage.

Set your region

AWS runs data centers in regions around the world. You need to pick one region where all your project resources will live.

• Look at the top-right corner of the console, next to your account name. You'll see a region name (e.g., US East (N. Virginia)).
• Click the region dropdown.
• Select a region close to your physical location. For example, select Asia Pacific (Seoul) if you're in Korea. The region code is ap-northeast-2.

Why does region matter?

Every resource you create (tables, functions, APIs) lives in the region you select. Picking one close to you means lower latency when testing your API.

All resources must be in the same region to communicate with each other. If you change regions mid-project, your resources won't be visible until you switch back.

Can't find the region dropdown?

The region selector is in the top-right navigation bar, between the bell icon and your account name. It displays the currently selected region name (not a code). Click it to see the full list of available regions.

help me find the region selector in AWS Console

Your AWS account is live and your region is locked in. Next up, you'll create a DynamoDB table to store your task data.

Create the DynamoDB Table

Your AWS account is ready and you're signed into the console. Now it's time to create your database.

Every application needs somewhere to store data. In this project, your tasks will live in a DynamoDB table. DynamoDB is a NoSQL database that AWS manages for you, so there are no servers to set up or maintain.

In this step, get ready to:

• Create a DynamoDB table called Tasks with a partition key.
• Verify the table is active and ready to receive data.

Create the Tasks table in DynamoDB

Your Lambda functions will write task records to this table and read them back. The table needs a partition key, which is a unique identifier for each item.

• In the AWS Console search bar at the top, type DynamoDB and select it from the results.
• Click Create table.
• In the Table name field, enter Tasks.
• In the Partition key field, enter task_id.
• Make sure the type dropdown next to the partition key is set to String.
• Leave all other settings as their defaults.
• Scroll to the bottom of the page and click Create table.

What is a partition key?

A partition key is the primary identifier for each item in a DynamoDB table. Every item must have a unique partition key value.

In your Tasks table, each task gets a unique task_id (generated by your Lambda function later). DynamoDB uses this key to quickly locate and retrieve individual items.

Why is this free?

DynamoDB is an Always Free tier service on AWS. You get 25 GB of storage at no cost, with no expiration date. For a portfolio project with occasional testing, you will never come close to these limits.

Verify the table is active

DynamoDB takes a few seconds to provision your table. You need to confirm it's ready before moving on.

• Wait for the table status to change to Active (this usually takes 10-20 seconds).
• Click on the Tasks table name to open it.
• Click the Explore table items button to view the Items section.

The items list is empty right now. This is where your task records will appear once your Lambda functions start writing data.

Table stuck on Creating?

If the status does not change to Active after 30 seconds, try refreshing your browser page. DynamoDB tables for this project should activate almost instantly.

If you see an error message, double-check that your region is still set correctly in the top-right corner of the console.

Still stuck? Help me troubleshoot my DynamoDB table creation.

Your database is ready. Next up, you'll create the Lambda functions that read and write task data to this table.

Create the Lambda Functions

Your DynamoDB table is ready and waiting for data. Now you'll create the functions that actually write to and read from it.

AWS Lambda lets you run code without managing servers. Each Lambda function handles one specific job: creating a task, getting a task, or listing all tasks. Together, they form the logic tier of your three-tier architecture.

In this step, get ready to:

• Create the CreateTask Lambda function with Python 3.13.
• Write and deploy the function code that saves tasks to DynamoDB.
• Create the GetTask and ListTasks functions with their code and permissions.

Create the CreateTask Lambda function

• In the AWS Console search bar at the top, type Lambda.
• Select Lambda from the results.
• Click Create function.
• Select Author from scratch.
• Set Function name to CreateTask.
• Set Runtime to Python 3.13.
• Set Architecture to x86_64.
• Under Permissions, expand Change default execution role.
• Select Create a new role with basic Lambda permissions.
• Click Create function at the bottom of the page.

What did you just create?

You created an empty Lambda function with its own IAM execution role. The role currently only has permission to write logs. You'll add DynamoDB access in a moment.

The Python 3.13 runtime means your code runs on Amazon Linux 2023 with boto3 (the AWS SDK for Python) pre-installed. No extra packages needed.

Deploy the CreateTask code and attach DynamoDB permissions

After the function is created, you'll land on a code editor page. This is where you write the logic that creates tasks in your DynamoDB table.

• In the code editor, select all the existing code in lambda_function.py and replace it with this code:

import json
import boto3
import uuid
from datetime import datetime, timezone

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Tasks')

def lambda_handler(event, context):
    body = json.loads(event['body'])

    task_id = str(uuid.uuid4())
    timestamp = datetime.now(timezone.utc).isoformat()

    item = {
        'task_id': task_id,
        'title': body['title'],
        'description': body.get('description', ''),
        'status': 'pending',
        'created_at': timestamp
    }

    table.put_item(Item=item)

    return {
        'statusCode': 201,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(item)
    }

What does this code do?

• boto3.resource('dynamodb') connects to DynamoDB using the AWS SDK that comes pre-installed in the Lambda runtime.
• json.loads(event['body']) reads the task title and description from the incoming HTTP request body.
• uuid.uuid4() generates a unique ID for each new task so no two tasks can collide.
• table.put_item(Item=item) writes the complete task record into your Tasks table.
• The function returns a 201 status code (meaning "created") along with the full task object as JSON.

• Click Deploy in the code editor toolbar to save your changes.
• You should see a "Successfully deployed" notification confirming the function was updated.

Now you need to give this function permission to access your DynamoDB table.

• Click the Configuration tab (above the code editor).
• Click Permissions in the left sidebar.
• Under Execution role, click the role name link. This opens the IAM console in a new tab.
• Click Add permissions.
• Click Attach policies.
• In the search bar, type AmazonDynamoDBFullAccess.
• Select the checkbox next to AmazonDynamoDBFullAccess.
• Click Add permissions.

Why AmazonDynamoDBFullAccess?

This managed policy gives your Lambda function read and write access to all DynamoDB tables in your account. For a learning project this is quick and effective.

In a production environment, you would create a custom policy scoped to only the Tasks table. This follows the principle of least privilege.

Don't see the role name link?

Make sure you're on the Configuration tab, then Permissions in the sidebar. The role name appears as a blue hyperlink under Execution role. If the page is still loading, wait a few seconds and refresh.

help me find the IAM role for my Lambda function

Create the GetTask and ListTasks functions

You'll now repeat the same process for two more functions. Each one handles a different API action.

• Close the IAM tab and return to the Lambda console tab.
• Click Functions in the left sidebar to go back to the functions list.
• Click Create function.
• Select Author from scratch.
• Set Function name to GetTask.
• Set Runtime to Python 3.13 and Architecture to x86_64.
• Under Permissions, expand Change default execution role and select Create a new role with basic Lambda permissions.
• Click Create function.

• In the code editor, select all the existing code in lambda_function.py and replace it with this code:

import json
import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Tasks')

def lambda_handler(event, context):
    task_id = event['pathParameters']['task_id']

    response = table.get_item(Key={'task_id': task_id})

    if 'Item' not in response:
        return {
            'statusCode': 404,
            'headers': {'Content-Type': 'application/json'},
            'body': json.dumps({'error': 'Task not found'})
        }

    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(response['Item'])
    }

What does this code do?

• event['pathParameters']['task_id'] reads the task ID from the URL path (e.g. /tasks/abc-123).
• table.get_item() looks up that specific task in DynamoDB by its partition key.
• If the task doesn't exist, the function returns a 404 error. Otherwise it returns the full task record.

• Click Deploy.
• Navigate to Configuration then Permissions, click the role name link, and attach the AmazonDynamoDBFullAccess policy using the same steps as before.

Now create the third function.

• Close the IAM tab and return to the Lambda console.
• Click Functions in the left sidebar.
• Click Create function.
• Select Author from scratch.
• Set Function name to ListTasks.
• Set Runtime to Python 3.13 and Architecture to x86_64.
• Under Permissions, expand Change default execution role and select Create a new role with basic Lambda permissions.
• Click Create function.

• In the code editor, select all the existing code in lambda_function.py and replace it with this code:

import json
import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Tasks')

def lambda_handler(event, context):
    response = table.scan()

    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(response['Items'])
    }

What does this code do?

• table.scan() reads every item in the Tasks table. For a small portfolio project this is fine.
• The function returns all tasks as a JSON array with a 200 status code.

• Click Deploy.
• Navigate to Configuration then Permissions, click the role name link, and attach the AmazonDynamoDBFullAccess policy using the same steps as before.

Confirm all three functions are deployed by clicking Functions in the left sidebar. You should see CreateTask, GetTask, and ListTasks listed.

Function not appearing in the list?

Make sure you clicked Create function (not just Deploy) when setting up each new function. If a function is missing, create it again from the Functions page. Also confirm your region hasn't changed in the top-right corner.

help me troubleshoot my missing Lambda function

✔️ Awesome, I've got everything!

Great. Make sure all three functions show "Successfully deployed" status and each has the AmazonDynamoDBFullAccess policy attached.

ⓧ I'd like to double check the full code

Here is the full code for each Lambda function. Compare yours against these.

CreateTask (lambda_function.py):

import json
import boto3
import uuid
from datetime import datetime, timezone

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Tasks')

def lambda_handler(event, context):
    body = json.loads(event['body'])

    task_id = str(uuid.uuid4())
    timestamp = datetime.now(timezone.utc).isoformat()

    item = {
        'task_id': task_id,
        'title': body['title'],
        'description': body.get('description', ''),
        'status': 'pending',
        'created_at': timestamp
    }

    table.put_item(Item=item)

    return {
        'statusCode': 201,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(item)
    }

GetTask (lambda_function.py):

import json
import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Tasks')

def lambda_handler(event, context):
    task_id = event['pathParameters']['task_id']

    response = table.get_item(Key={'task_id': task_id})

    if 'Item' not in response:
        return {
            'statusCode': 404,
            'headers': {'Content-Type': 'application/json'},
            'body': json.dumps({'error': 'Task not found'})
        }

    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(response['Item'])
    }

ListTasks (lambda_function.py):

import json
import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Tasks')

def lambda_handler(event, context):
    response = table.scan()

    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(response['Items'])
    }

Your logic tier is complete. All three functions are deployed and have permission to read and write from your Tasks table. Next up, you'll connect them to the internet by building a REST API with API Gateway.

Build the REST API with API Gateway

Your three Lambda functions are deployed and ready to process requests. The problem is that nobody can reach them yet.

Lambda functions live inside AWS and can only be triggered by other AWS services or events. To make them accessible over the internet as a REST API, you need a front door that accepts HTTP requests and routes them to the right function. That front door is Amazon API Gateway.

In this step, get ready to:

• Create a REST API in API Gateway.
• Wire up resources and methods to your Lambda functions.
• Deploy the API and get a live public URL.

Create the REST API

API Gateway offers several API types. You need a REST API because it supports resource-based routing (like /tasks and /tasks/{task_id}) and Lambda proxy integration.

• In the AWS Console search bar at the top, type API Gateway and select it from the results.
• Click Create API.
• Find the REST API card (not REST API Private) and click Build.
• For API name, enter TaskTrackerAPI.
• Leave all other settings as their defaults.
• Click Create API.

What is API Gateway?

API Gateway is a fully managed AWS service that acts as the presentation tier of your architecture. It receives HTTP requests from the outside world, routes them to backend services like Lambda, and returns responses to the caller.

Think of it as a receptionist for your application. Clients never talk to Lambda directly. They send requests to API Gateway, which decides which function handles each request.

Create the resources and methods

In API Gateway, a resource is a URL path (like /tasks) and a method is an HTTP verb (like POST or GET) attached to that path. You will create two resources and three methods total.

Start by creating the /tasks resource.

• Click Create resource.
• For Resource path, enter /tasks.
• Click Create resource.

Now add a POST method on /tasks to handle creating new tasks.

• With /tasks selected in the resource tree, click Create method.
• For Method type, select POST.
• For Integration type, select Lambda Function.
• Turn on Lambda proxy integration (toggle it to active).
• For Lambda function, select your CreateTask function.
• Click Create method.

What is Lambda proxy integration?

With proxy integration turned on, API Gateway passes the entire HTTP request (headers, body, path parameters, query strings) directly to your Lambda function as the event object. Your function then returns a response with statusCode, headers, and body.

This is the most common pattern for serverless APIs because it keeps the setup simple. You do not need to configure request or response mappings manually.

Next, add a GET method on /tasks to handle listing all tasks.

• With /tasks still selected, click Create method.
• For Method type, select GET.
• For Integration type, select Lambda Function.
• Turn on Lambda proxy integration.
• For Lambda function, select your ListTasks function.
• Click Create method.

Now create a child resource under /tasks for retrieving a single task by its ID.

• Click on /tasks in the resource tree to select it.
• Click Create resource.
• For Resource path, enter {task_id}.
• Click Create resource.

Why curly braces in the path?

The curly braces around {task_id} tell API Gateway this is a path parameter. When someone requests /tasks/abc-123, API Gateway captures abc-123 and passes it to your Lambda function inside event['pathParameters']['task_id'].

Finally, add a GET method on /{task_id} to retrieve a single task.

• With /{task_id} selected, click Create method.
• For Method type, select GET.
• For Integration type, select Lambda Function.
• Turn on Lambda proxy integration.
• For Lambda function, select your GetTask function.
• Click Create method.

Your resource tree should now show /tasks with POST and GET methods, and a child /{task_id} with a GET method.

Don't see your Lambda function in the dropdown?

Make sure you are in the same AWS region where you created your Lambda functions. Check the region dropdown in the top-right corner of the console.

If the function still does not appear, try typing the first few characters of the function name (e.g. Create) to filter the list.

Help me troubleshoot why my Lambda function is not appearing in the API Gateway integration dropdown.

Deploy the API to a live stage

Your API exists but is not publicly accessible yet. Deploying it creates a live URL that anyone on the internet can call.

• Click Deploy API (orange button near the top of the page).
• For Stage, select New stage.
• For Stage name, enter prod.
• Click Deploy.

You will see an Invoke URL displayed at the top of the stage page. This is your live API endpoint.

• Copy this URL and save it somewhere handy (a text file or sticky note). You will use it in the next step to test your API.

What does the Invoke URL look like?

Your Invoke URL follows this format:

https://YOUR-API-ID.execute-api.YOUR-REGION.amazonaws.com/prod.

The YOUR-API-ID part is a unique identifier AWS assigned to your API. The /prod at the end is the stage name you just chose.

Don't see the Invoke URL?

After clicking Deploy, you should land on the stage details page automatically. If you navigated away, click Stages in the left sidebar, then select prod. The Invoke URL appears under Stage details.

Help me find my API Gateway Invoke URL after deploying to the prod stage.

Your API is live. In the next step, you will test it by sending real HTTP requests and watching data flow through all three tiers of your architecture.

Test Your Live API

Your API is deployed and live on the internet. Now it's time to prove the entire system works end-to-end.

You'll use curl, a command-line tool that sends HTTP requests, to hit each of your API endpoints. Does data actually flow from your request through API Gateway, into Lambda, and down to DynamoDB?

In this step, get ready to:

• Create a new task by sending a POST request to your API.
• Retrieve tasks using GET requests to verify data persistence.
• Confirm the full data flow by checking DynamoDB directly.

Create a task with a POST request

Your first test sends data into the system. A POST request creates a new task record that flows through all three tiers of your architecture.

• Open Command Prompt by pressing the Windows key, typing cmd, and pressing Enter.
• Before running the command below, find your Invoke URL. This is the URL from the previous step that looks like https://abc123.execute-api.ap-northeast-2.amazonaws.com/prod.
• Create a new task by running this command (replace the Invoke URL with yours):

curl -X POST [[INVOKE_URL="your Invoke URL from API Gateway"]]/tasks -H "Content-Type: application/json" -d "{\"title\":\"Learn AWS\",\"description\":\"Complete the serverless project\"}"

What does this command do?

• curl -X POST sends an HTTP POST request to create a new resource.
• -H "Content-Type: application/json" tells the API that you're sending JSON data in the request body.
• -d provides the JSON body with a title and description for your task.

You should see a JSON response that includes a task_id (a long unique string), a status of pending, and a created_at timestamp.

Copy your task_id

Copy the task_id value from the response. You'll need it in the next substep to retrieve this specific task.

Seeing an error instead of JSON?

• Double-check your Invoke URL. It should end with /prod followed by /tasks (no trailing slash after tasks).
• Make sure you deployed your API in the previous step. If you skipped the Deploy step, go back to API Gateway, click Deploy API, and select the prod stage.
• If you see Internal server error, check that your CreateTask Lambda function's IAM role has the AmazonDynamoDBFullAccess policy attached.

Help me debug my curl POST request to API Gateway.

Retrieve tasks with GET requests

Now you'll confirm that your data persisted by reading it back. Two GET endpoints let you fetch all tasks or one specific task by ID.

• List all tasks in your database by running:

curl [[INVOKE_URL="your Invoke URL from API Gateway"]]/tasks

You should see a JSON array containing the task you just created.

• Retrieve a single task by its ID by running this command (replace the task_id with the one from your create response):

curl [[INVOKE_URL="your Invoke URL from API Gateway"]]/tasks/[[TASK_ID="the task_id from your create response"]]

What should I see?

The first command returns a JSON array with all tasks. The second command returns a single JSON object with the matching task_id, title, description, status, and created_at fields.

If you get a Task not found error on the second command, make sure you pasted the full task_id value without any extra spaces.

Getting an empty array from the list endpoint?

• Make sure your POST request in the previous substep returned a successful 201 response with a task_id. If it didn't, re-run the POST command first.
• Verify your ListTasks Lambda function's IAM role has the AmazonDynamoDBFullAccess policy attached.

Help me debug why my GET request returns an empty response.

Verify data in DynamoDB

The final proof is seeing your task records directly in the database. This confirms the complete three-tier flow worked from start to finish.

• Switch back to the AWS Management Console in your browser.
• In the search bar at the top, type DynamoDB and select it.
• Click on your Tasks table.
• Click the Explore table items button.

You should see the task record you created through your API, including the task_id, title, description, status, and created_at fields.

What does this prove?

Seeing your data here confirms the full three-tier architecture is working. API Gateway received your HTTP request (presentation tier). Lambda processed the business logic and generated the task ID (logic tier). DynamoDB stored the record permanently (data tier).

This is the same serverless pattern that AWS Solutions Architects recommend to customers building scalable applications.

Secret mission

Add Delete and Status Update Endpoints

Your API can create and read tasks, but real task trackers need to mark tasks as done and remove them entirely. Can you extend your API with DELETE and PATCH endpoints using the same patterns you already learned?

Clean Up Your Resources

Clean Up Your Resources

All resources in this project run on AWS Always Free tier services. As long as you stay within the monthly limits (1M Lambda requests, 1M API Gateway calls, 25 GB DynamoDB storage), these resources cost nothing.

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

• 1 DynamoDB table (Tasks).
• 5 Lambda functions (CreateTask, GetTask, ListTasks, DeleteTask, UpdateTaskStatus).
• 1 REST API in API Gateway (TaskTrackerAPI).
• 5 IAM execution roles (one per Lambda function).
• 1 AWS account (Free plan).

Keep everything running

No action needed. Choose this if you plan to use this API as a portfolio piece or interview demo.

• These resources cost $0 within Always Free limits. You will never come close to the limits with occasional testing.
• Your API endpoint remains live and accessible for demonstrations.
• Your AWS account stays open with the Free plan active.

Pause - I'll come back to this later

Since all resources are serverless and Always Free, there is nothing to pause. They only consume resources when called.

• Lambda functions only run when invoked. No invocations means no usage.
• DynamoDB only charges for storage beyond 25 GB. A few task records use negligible space.
• API Gateway only charges per request. No requests means no cost.
• Leave everything as-is and return whenever you are ready.

Delete - I don't want to use this again

Remove all project resources from your AWS account. The order does not matter.

Delete the REST API

• Open the APIs page of the API Gateway console.
• Select TaskTrackerAPI.
• Choose Actions, then Delete.
• Choose Delete to confirm.

Delete the Lambda functions

• Open the Functions page of the Lambda console.
• Select CreateTask.
• Choose Actions, then Delete.
• Type confirm in the text input field and choose Delete.
• Repeat for GetTask, ListTasks, DeleteTask, and UpdateTaskStatus.

Delete the DynamoDB table

• Open the Tables page of the DynamoDB console.
• Select the Tasks table.
• Choose Delete.
• Enter delete in the text box and choose Delete table.

Delete the IAM execution roles

• Open the Roles page of the IAM console.
• Search for the execution role associated with each Lambda function (the role name starts with the function name).
• Select the role and choose Delete.
• Enter the role name in the text input field and choose Delete.
• Repeat for all five execution roles.

That's a Wrap!

That's a Wrap!

Nice work! You just deployed a production-ready serverless architecture on AWS.

You've learned how to:

• Build a three-tier serverless architecture on AWS using API Gateway, Lambda, and DynamoDB.
• Create Python Lambda functions implementing CRUD business logic with proper IAM permissions.
• Configure a REST API with path parameters and Lambda proxy integration, deployed to a live public endpoint.
• Added delete and status update capabilities using DynamoDB update expressions.

This project demonstrates you can architect and deploy scalable serverless applications on AWS. That is exactly what Solutions Architect Interns help customers do.

Ready to quiz yourself?