If you're stepping into serverless computing, AWS Lambda is likely the name you've come across a few times already. And if you're wondering whether it's as flexible and lightweight as they say, it is. At its core, Lambda is about running code without worrying about the infrastructure underneath. You write the function, deploy it, and AWS handles the execution. Simple in theory, yet there's a process that requires a bit of walking through.

Let’s break down how to create your very first Lambda function, step by step. No assumptions, no skipping over the essentials. Just a clear, complete walkthrough you can rely on.

What Is AWS Lambda (And Why It Matters)

Before diving into the console, it's important to understand what exactly you're dealing with. AWS Lambda is a compute service from Amazon Web Services that runs your code in response to events and automatically manages the computing resources. You don't have to manage servers. You don't have to configure scaling policies. In fact, you don’t even have to think about provisioning capacity.

In other words, Lambda gives you efficiency with minimal overhead. That’s its real strength.

Step 1: Setting Up the Basics

Before you write a single line of code, there’s some groundwork that needs to be done. Nothing complex—just the initial setup that ensures you're ready to go.

Sign in to the AWS Console

Start by logging into the AWS Management Console. If you don’t already have an AWS account, you’ll need to create one. Once signed in, navigate to the Lambda service using the search bar at the top.

Region Selection

Choose your preferred region in the upper-right corner of the console. Lambda functions are region-specific, so any resources you connect later (like an S3 bucket or an API Gateway) should ideally reside in the same region.

IAM Role (Execution Role)

AWS Lambda needs permission to execute functions on your behalf. This is handled through an IAM role—specifically, an execution role. When creating your Lambda function, AWS can generate this role for you with basic permissions. For now, that’s all you need.

Step 2: Creating the Function

With the prep done, it’s time to actually create the Lambda function. AWS gives you multiple options: authoring from scratch, using a blueprint, or importing from a container image. For your first time, it’s best to start from scratch.

Navigate to “Create Function”

Once you're in the Lambda console, click Create Function. You’ll be presented with a form to configure your new function.

Fill in the Details

• Function name: Give your function a meaningful name like HelloWorldLambda.
• Runtime: Choose your language. For this tutorial, let’s go with Python 3.12.
• Permissions: Choose "Create a new role with basic Lambda permissions." This sets up an IAM role that allows your function to write logs to Amazon CloudWatch.

Click the Create function. AWS will take a few seconds to set things up.

Step 3: Writing the Code

Now comes the part where you actually write your function. AWS gives you a built-in editor inside the console for quick scripts and testing.

Basic Hello World Function

By default, AWS inserts a basic handler function for you. If it’s not already there, replace the code in the editor with this:

def lambda_handler(event, context):

return {

'statusCode': 200,

'body': 'Hello from Lambda!'

}

This is your function. The event parameter holds the incoming request data, and context gives you metadata about the invocation. In this case, the function simply returns a 200 response and a short message.

Click Deploy once you're done editing. This saves the function code and makes it ready for execution.

Step 4: Testing the Function

You now have a function. It's deployed and ready to run. But how do you know it works? AWS makes that part pretty easy, too.

Create a Test Event

Click the Test button at the top. You’ll be prompted to configure a test event.

• Event name: Call it something like TestEvent1.
• Template: Leave the default hello-world JSON, or input your own event data if you like.

Click Create, then hit Test again to run your function.

View the Results

After running the test, the execution result will appear at the top of the console. You should see a response similar to:

{

"statusCode": 200,

"body": "Hello from Lambda!"

}

You’ll also see logs from the execution below, showing duration, memory used, and log output. This is useful when you're troubleshooting or optimizing performance later on.

Step 5: Adding a Trigger (Optional But Worth It)

Right now, your function exists, and you can test it manually. But Lambda really shines when it's connected to an actual event source. For instance, you can make it respond to an HTTP request or a file upload.

Let’s wire it up to API Gateway, so your Lambda can be triggered through a browser or HTTP client.

Add API Gateway as a Trigger

• From your Lambda function’s page, click Add trigger.
• Choose API Gateway.
• Select Create an API, then HTTP API.
• Leave the security as Open (for testing purposes—don’t use this for production).
• Click Add.

You’ll get an API endpoint URL that you can now open in a browser or run using curl. When you hit it, the Lambda function will execute and return the message.

Step 6: Viewing Logs in CloudWatch

Each time your Lambda function runs, it sends logs to Amazon CloudWatch automatically. These logs are valuable for tracking execution details, error messages, and anything you print() inside your function.

To see the logs:

• Go to the Monitoring tab of your function.
• Click View logs in CloudWatch.
• Select the latest log stream.

Here you’ll find timestamps, request IDs, and any messages from your function’s execution. It’s clean, structured, and extremely helpful for debugging.

Wrapping Up

Creating your first Lambda function isn’t complicated, but it does follow a specific flow. You start with a basic setup, define your function, deploy it, test it, and (optionally) link it to a trigger. That’s all there is to it. The real magic of Lambda unfolds when you start chaining it with other AWS services. But even at the simplest level, it delivers on its promise: code execution without servers to manage.