AWS Lambda Beginner Guide 2026 (First Function + Deploy)

AWS Lambda lets you run backend code without provisioning or managing servers. You write a function, upload it, and AWS runs it on demand. No EC2 instances to patch, no auto-scaling groups to configure, no idle costs when nothing calls your code. This 2026 beginner guide walks you through creating your first Lambda function, setting up an IAM execution role, connecting a trigger, and deploying updates from the terminal with the AWS CLI.

What is AWS Lambda (and why serverless matters in 2026)

AWS Lambda is the original serverless compute service, launched in 2014. You give AWS a function, AWS runs it whenever something triggers it (HTTP request, file upload, database event, scheduled cron), and you pay per invocation and per 100 milliseconds of runtime. No servers to manage. No fixed hourly costs.

The 2026 shift: serverless is now the default for event-driven backends, webhooks, chat bots, ETL jobs, image processing, and any workload with unpredictable traffic. Netflix, Coca-Cola, Nordstrom, and thousands of smaller shops run production Lambda at scale. If you build backends without learning Lambda in 2026, you are working two years behind.

Prerequisites (5 minutes of setup)

You need three things before your first function:

• An AWS account (sign up at aws.amazon.com, credit card required but Lambda free tier covers learning use easily)
• The AWS CLI installed (Mac: brew install awscli, Windows: MSI installer from aws.amazon.com/cli, Linux: pip install awscli)
• AWS credentials configured (run aws configure and paste your Access Key ID + Secret from IAM → Users → Security credentials)

Verify the CLI works: aws sts get-caller-identity. You should see your account ID + user ARN. If yes, you are ready.

Create your first Lambda in the AWS Console

Open the Lambda console (console.aws.amazon.com/lambda), click Create function, and pick Author from scratch. Fill in:

• Function name: my-first-function
• Runtime: Python 3.12 (or Node.js 22 if you prefer JavaScript)
• Architecture: arm64 (cheaper, faster, use unless you need x86-specific libraries)
• Execution role: Create a new role with basic Lambda permissions (AWS handles this automatically)

Click Create function. AWS provisions the function, creates the IAM role, and drops you in the code editor with a starter handler:

import json

def lambda_handler(event, context):
    return {
        'statusCode': 200,
        'body': json.dumps('Hello from Lambda!')
    }

Click Deploy, then Test, name the test event test1, keep the default JSON payload, click Save, and click Test. You should see a green success box with "body": "\"Hello from Lambda!\"". That is your function executing on real AWS infrastructure.

Understand IAM roles (the concept that trips up everyone)

Every Lambda function needs an execution role. The role grants the function permissions to interact with other AWS services (S3, DynamoDB, SNS, CloudWatch Logs). Without a role, Lambda cannot even write its own log output.

The auto-created basic role gives your function only CloudWatchLogs permissions (write log lines). To read from an S3 bucket, you attach an AmazonS3ReadOnlyAccess policy. To write to DynamoDB, you attach AmazonDynamoDBFullAccess (or a narrower custom policy in production). This principle-of-least-privilege model catches nearly every “Access Denied” error you will hit.

To edit the role: Configuration tab → Permissions → click the role name → Attach policies. Then re-invoke the function.

Add a trigger (API Gateway = HTTP endpoint in 2 clicks)

Console → your function → Add trigger → select API Gateway → API type HTTP API → security Open (fine for learning, add auth later) → click Add. AWS creates an HTTP API Gateway, links it to your Lambda, and gives you a public URL like https://abc123.execute-api.us-east-1.amazonaws.com/default/my-first-function.

Curl it: curl https://abc123.execute-api.us-east-1.amazonaws.com/default/my-first-function. You get back "Hello from Lambda!". You just deployed a serverless HTTP endpoint in under 5 minutes. Zero servers to manage.

Deploy updates from the terminal (AWS CLI workflow)

The console is fine for learning. Real work happens from the terminal. Zip your code, upload the zip:

zip function.zip lambda_function.py
aws lambda update-function-code \
    --function-name my-first-function \
    --zip-file fileb://function.zip

Invoke it directly from the CLI without going through API Gateway:

aws lambda invoke \
    --function-name my-first-function \
    --payload '{"key1":"value1"}' \
    response.json
cat response.json

Add this to your CI/CD pipeline and every git push deploys a new function version automatically.

Common AWS Lambda pitfalls in 2026

• Cold starts. First invocation after idle takes 200-1000 ms as AWS spins up a container. Warm invocations are 5-50 ms. For latency-critical APIs, use Provisioned Concurrency or SnapStart (Java).
• 15-minute execution limit. Lambda kills any invocation running over 15 minutes. For longer jobs (video encoding, large ETL), use Step Functions or AWS Batch instead.
• 250 MB unzipped package size. Big ML libraries (torch, tensorflow) blow this out. Use Lambda Layers to share dependencies, or use container image deployment (up to 10 GB).
• No local disk. Only /tmp is writable (512 MB default, up to 10 GB configurable). Nothing persists between invocations. Use S3 or DynamoDB for state.
• CloudWatch cost surprise. Log lines add up fast. Set log retention to 7 or 14 days on your log group (default is Never Expire, which bills forever).

Where AWS Lambda fits in the 2026 stack

Lambda is the right pick when: your workload is event-driven, traffic is spiky or unpredictable, you want zero infrastructure work, and you can fit the job in 15 minutes and 10 GB of memory. Lambda is the wrong pick when: you have steady sustained traffic (EC2 or Fargate is cheaper), you need long-running WebSockets (API Gateway WebSockets are usable but awkward), or your job needs specialized hardware (GPU inference).

Learning path: master Lambda → learn API Gateway (REST + HTTP APIs) → learn SAM or Serverless Framework for infrastructure-as-code → learn Step Functions for orchestrating multiple Lambdas → learn AWS SAM Accelerate for hot-reload local development. Each layer builds on the previous. Do not skip to Step Functions before you understand a single Lambda well.

Try these hosting + tool partners for your serverless projects

Quick step-by-step summary (click to expand)

1. Sign up for AWS + install the AWS CLI. Create an AWS account at aws.amazon.com. Install the CLI: brew install awscli on Mac, MSI installer on Windows, pip install awscli on Linux.
2. Configure your credentials. Run aws configure and paste your Access Key ID + Secret from IAM > Users > Security credentials. Test with aws sts get-caller-identity.
3. Create a function in the AWS Console. Open Lambda console > Create function > Author from scratch > name my-first-function > runtime Python 3.12 > architecture arm64 > create.
4. Test the default handler. Click Test, name the event test1, keep default payload, click Save then Test. You should see 200 status with body Hello from Lambda!
5. Deploy updates from your terminal. Zip your code: zip function.zip lambda_function.py. Upload: aws lambda update-function-code –function-name my-first-function –zip-file fileb://function.zip.

Related Cloud + DevOps tutorials

• Docker Complete Beginner Guide 2026 (First Container)
• Kubernetes for Beginners 2026 (Complete Practical Tutorial)
• Azure Functions vs AWS Lambda 2026 (coming this week)
• Serverless Framework Complete Guide 2026 (coming this week)

Official documentation

• AWS Lambda: official documentation
• AWS CLI Lambda reference
• Lambda pricing: current tier + calculator