Serverless with AWS Lambda: Practical Guide for Scalable Applications

Serverless is not just a buzzword, it is an execution model that allows you to focus exclusively on business logic, leaving the infrastructure in the hands of the cloud. In this article, we will walk through the entire lifecycle of an AWS Lambda application, from function writing to cost optimization.

Why Choose Serverless?

Automatic scaling, Each invocation receives its own container, without the need to provision servers.
Cost per use, You only pay for the execution time (milliseconds) and number of invocations.
Delivery speed, fast deployments, without managing clusters or VMs.

Project Structure

The organization of a serverless service is deliberately simple. At the root are serverless.yml, which concentrates the configuration of the Serverless Framework, and package.json. Lambda function code lives under src/, typically in an handler.js, while corresponding tests are isolated in tests/, such as handler.test.js. This separation keeps the function, its configuration, and its verification visible side by side.

Implementation Step by Step

1. Serverless Framework Configuration

service: minha-funcao
provider:
  name: aws
  runtime: nodejs20.x
  region: us-east-1
  memorySize: 128
  timeout: 10
functions:
  hello:
    handler: src/handler.hello
    events:
      - http:
          path: hello
          method: get
          cors: true
plugins:
  - serverless-offline

2. Writing the Lambda Function

// src/handler.js
exports.hello = async (event) => {
  const name = event.queryStringParameters?.name || 'Mundo';
  return {
    statusCode: 200,
    body: JSON.stringify({ message: `Olá, ${name}!` }),
    headers: { 'Content-Type': 'application/json' }
  };
};

3. Unit Tests with Jest

// tests/handler.test.js
const { hello } = require('../src/handler');

test('retorna saudação padrão', async () => {
  const event = { queryStringParameters: {} };
  const result = await hello(event);
  expect(JSON.parse(result.body)).toEqual({ message: 'Olá, Mundo!' });
});

4. Local Deploy with `serverless offline`

npm install
npx serverless offline start

Access http://localhost:3000/dev/hello?name=Matheus and see the answer.

5. Deploy to AWS

npx serverless deploy

The command creates the Lambda function, API Gateway, and required permissions.

Cost Optimization

Memory choice: memory and CPU are proportional. Test different sizes and measure latency.
Use of layers: share dependencies between functions to reduce package size.
Provisioned Concurrency: For cool latency, enable provisioned concurrency on critical functions.
Monitoring: use CloudWatch Metrics (Duration, Invocations, Errors) to identify underutilized functions.

Good Security Practices

Principle of Least Privilege, Set minimum IAM policies for each role.
Encrypted environment variables, Use kms for sensitive secrets.
Input validation, Never trust customer data; validate schemas with ajv or similar.

Serverless Deployment Checklist

Configure serverless.yml with provider, runtime and region.
Write handler function with error handling.
Implement unit tests.
Test locally with serverless offline.
Deploy to AWS and validate endpoint.
Configure monitoring and alarms.
Review IAM policies.
Optimize memory and provisioned concurrency.

Conclusion

Serverless allows teams to deliver functionality quickly, reducing operational burden. By following this guide, you'll have a solid foundation for creating APIs, processing events, and building data pipelines without managing servers.

Have you ever used AWS Lambda? Share your optimization tips in the comments!