AWS Builder Center
Build Your First Serverless Application with AWS Lambda and Amazon API Gateway

Build Your First Serverless Application with AWS Lambda and Amazon API Gateway

Learn how AWS Lambda and Amazon API Gateway work together to build a simple serverless API. This beginner-friendly guide explains serverless architecture, Lambda functions, API integration, benefits, and practical next steps.

Introduction

Building a web application traditionally requires managing servers, operating systems, scaling, and infrastructure. AWS serverless services make this easier by allowing developers to focus mainly on application logic instead of managing servers.
In this article, we will understand how AWS Lambda and Amazon API Gateway work together to create a simple serverless application.

What Is Serverless Computing?

Serverless computing does not mean that servers do not exist. Instead, AWS manages the underlying servers, infrastructure, scaling, and much of the operational work for you.
With serverless architecture:
  • You don't need to manage physical servers.
  • Applications can automatically scale based on demand.
  • You generally pay for the resources your application actually uses.
  • Developers can focus on writing application code.
Two important AWS services for this architecture are AWS Lambda and Amazon API Gateway.

What Is AWS Lambda?

AWS Lambda is a compute service that runs your code without requiring you to provision or manage servers.
A Lambda function runs when it is invoked by an event. For example, it can be triggered by:
  • An API request
  • An Amazon S3 event
  • A scheduled event
  • A message from another AWS service
A Lambda function can be written in languages such as Python, Java, JavaScript/Node.js, and others supported by AWS.

Simple Lambda Example

Here is a basic Python Lambda function:
def lambda_handler(event, context):
return {
"statusCode": 200,
"body": "Hello from AWS Lambda!"
}
The function receives an  event  containing information about the request and a  context  containing information about the Lambda execution environment.

What Is Amazon API Gateway?

Amazon API Gateway is a managed service that allows applications to create, publish, monitor, and secure APIs.
It can receive an HTTP request and forward it to a backend such as an AWS Lambda function.
For example:
User
|
| HTTP Request
v
API Gateway
|
| Invoke
v
AWS Lambda
|
v
Response
|
v
User
This creates a simple serverless backend without requiring you to maintain a traditional web server.

How Lambda and API Gateway Work Together

Consider a simple application that provides a greeting.
The user sends:
GET /hello
API Gateway receives the request and invokes the Lambda function.
Lambda executes:
def lambda_handler(event, context):
return {
"statusCode": 200,
"body": "Hello! Welcome to my serverless application."
}
The response is then returned through API Gateway to the user.
The complete flow is:
Client
|
| GET /hello
v
API Gateway
|
| Invoke Lambda
v
Lambda Function
|
| Generate Response
v
API Gateway
|
v
Client

Steps to Create a Simple Serverless API

Step 1: Create a Lambda Function

Open the AWS Lambda console and create a new function.
Choose:
  • Author from scratch
  • A function name such as  hello-serverless 
  • Python as the runtime
Then add the following code:
def lambda_handler(event, context):
return {
"statusCode": 200,
"headers": {
"Content-Type": "text/plain"
},
"body": "Hello from my serverless API!"
}
Deploy the function and test it using the Lambda test feature.

Step 2: Create an API

Open Amazon API Gateway and create an HTTP API.
Configure the API to use your Lambda function as the integration.
For example:
GET /hello
can be connected to:
hello-serverless

Step 3: Test the API

After creating the API, API Gateway provides an invoke URL.
Opening the endpoint should return:
Hello from my serverless API!
You have now created a basic serverless API.

Advantages of This Architecture

1. No Server Management

AWS manages the underlying infrastructure, allowing developers to concentrate on application development.

2. Automatic Scaling

Lambda can run multiple function instances as requests increase, making it suitable for workloads with changing traffic.

3. Cost Efficiency

For applications with intermittent workloads, serverless architecture can be cost-effective because you don't need to keep a traditional server running continuously.

4. Faster Development

Developers can create APIs and backend functionality without spending significant time configuring servers.

5. Easy Integration

Lambda can integrate with many AWS services, making it useful for event-driven applications.

When Should You Use Serverless?

Serverless architecture can be a good choice for:
  • REST APIs
  • Web application backends
  • Automation tasks
  • Scheduled jobs
  • Data processing
  • Event-driven applications
  • Lightweight microservices
However, serverless is not automatically the best choice for every workload. Applications with long-running processes, specialized infrastructure requirements, or particular performance characteristics may benefit from other architectures.

Important AWS Services to Learn Next

After learning Lambda and API Gateway, beginners can explore:
  • Amazon S3 – Object storage
  • Amazon DynamoDB – NoSQL database
  • Amazon CloudWatch – Monitoring and logging
  • AWS IAM – Identity and access management
  • Amazon SQS – Message queuing
  • Amazon EventBridge – Event-driven architectures
Together, these services can be used to build more complete serverless applications.

Conclusion

AWS Lambda and Amazon API Gateway provide a simple way to build scalable APIs without managing traditional servers.
The key idea is straightforward:
API Gateway → Lambda → Response
Once you understand this basic architecture, you can extend it by adding databases, authentication, monitoring, storage, and event-driven workflows.
For beginners learning AWS, building a small serverless API is a practical way to understand how modern cloud applications are designed and deployed.
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