AWS Lambda and Step Functions Made Simple: A Beginner’s Guide

Introduction

AWS Lambda and AWS Step Functions are two foundational serverless services from AWS that let you run code without managing infrastructure. This article will help you understand these services, how they differ, and how to use them together to build automated workflows.

AWS Lambda: On-Demand Code Execution

What is it for?

Lambda is used to run a short function (like a mini task), only when needed. No container, no server.

When do you use it?

• When you just want to respond to an event (for example: an API call, an image arriving in S3…)
• When your code is short and only runs for a few seconds at a time
• When you want to pay only for what you use

Concrete example:

Someone submits a form on your site. You want to send an email automatically.
You write a function that does that (in Python or Node), and you tell Lambda:

“Run this code only when the form is submitted.”

AWS Step Functions: Workflow Orchestration

What is it for?

Step Functions lets you coordinate multiple Lambda functions and other AWS services in a visual, no-code workflow.

When do you use it?

• When you have a process that requires multiple steps
• When you want to handle errors and retries gracefully
• When you want to visualize and track the execution of your workflow

Concrete example:

You have a user registration process that requires several steps:

1. Validate the information
2. Create an account in the database
3. Send a confirmation email
4. Generate a default profile

You can orchestrate all of this with Step Functions without writing any orchestration code.

Comparison with Fargate

Characteristic	Fargate	Lambda
App type	Full application	Short function / single task
Deployment format	Docker container	Code (.js, .py file, etc.)
Starts when?	Always on or on demand	Only when something happens
Execution duration	Long-running (minutes, hours, days)	Short-lived (a few seconds, max 15 min)
Typical use	Web APIs, backend, websites, microservices	One-off tasks, automation, lightweight APIs
Level of control	Medium (you manage your container)	Very low (you only manage the code)
Billing	Per minute of container runtime	Per invocation and exact execution time

Concrete Use Cases

Example for an e-commerce site:

• You have a full backend with cart, login, and payment → Fargate
• When someone makes a purchase, you want to email a receipt → Lambda
• You want to orchestrate the entire purchase process → Step Functions

Example for an image processing system:

• You want to process images when they are uploaded → Lambda
• You want to orchestrate several steps (resizing, compression, analysis) → Step Functions

How Lambda and Step Functions Work Together

Step Functions uses Lambda as one of its possible “states” (steps). Here is how they fit together:

1. You create several Lambda functions for different tasks
2. You define a workflow in Step Functions that calls these functions in a specific order
3. Step Functions handles execution, retries, and error handling

Example Step Functions Workflow

{
  "Comment": "Un workflow de traitement de commande",
  "StartAt": "VérifierCommande",
  "States": {
    "VérifierCommande": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:VerifierCommande",
      "Next": "TraiterPaiement"
    },
    "TraiterPaiement": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:TraiterPaiement",
      "Next": "PréparerLivraison"
    },
    "PréparerLivraison": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:PreparerLivraison",
      "End": true
    }
  }
}

Best Practices

For Lambda

1. Keep functions small and focused: One function = one task
2. Use appropriate timeouts: Maximum 15 minutes for Lambda
3. Handle errors properly: Return appropriate error codes
4. Use environment variables for configuration
5. Optimize the deployment package to reduce startup times

For Step Functions

1. Design idempotent workflows: They should be able to run multiple times without issues
2. Use appropriate timeouts for each state
3. Implement robust error handling with recovery states
4. Use conditional branches to handle different scenarios
5. Limit workflow complexity to keep them readable

Conclusion

AWS Lambda and Step Functions are powerful services that let you build sophisticated serverless applications without managing infrastructure. Lambda is ideal for running code on demand, while Step Functions lets you orchestrate multiple functions and services into complex workflows.

By understanding the strengths and use cases of each service, you will be able to design efficient, scalable serverless architectures.

Additional Resources

• AWS Lambda Documentation
• AWS Step Functions Documentation
• AWS Serverless Application Model (SAM)
• Serverless Workshop with Lambda and Step Functions