Why We Prefer AWS Lambda

To be clear, the benefits of serverless computing are no longer up for debate. Building applications without wrangling servers, but with pay-per-use models and automatic scaling, is a no-brainer, especially for event-driven architectures.

The real question is which platform to choose. While open-source tools like The Serverless Framework work well with competitors like Google Cloud Functions and Azure Functions, our preference often leans towards AWS Lambda.

Ultimately, it boils down to the client's existing infrastructure, but we value Lambda for its maturity and ecosystem. It’s been in the game longer, which translates to more features, the best documentation, and excellent out-of-the-box performance. AWS also supports several languages we use daily, including Java and JavaScript (Node.js), so our teams can be productive immediately.

The real power, however, lies in the integrations with other AWS services. You can easily set up code to respond to triggers like file changes in an S3 bucket, new items in a DynamoDB table, or HTTP requests via API Gateway.

‍

Building a Scalable Architecture with AWS Lambda

While Lambda’s pay-per-use model is great for costs, it means you have to be disciplined about architecture. To help our consultants build scalable and resilient systems, we focus on a few practical principles in our bootcamps.

Here are some key things to keep in mind:

• Be pragmatic about where you use it. Serverless is fantastic for event-driven applications, but traditional methods might still be better for tasks with very long runtimes.
• Don't "lift and shift" old applications. Lambda works best for new software designed around events; you can't easily refactor a monolith into a function.
• Define your triggers properly. A function is useless if it doesn't activate in response to the right events.
• Use queues to decouple your functions. This makes your system more resilient. If a function fails, the message can be retried. (We talk more about this in our post on Amazon SQS).
• Avoid the "God Lambda". Don't try to put all your logic in one function. Use Domain-Driven Design principles to split the application into focused, single-responsibility functions.
• Be mindful of your function's return type. It’s a common source of strange, hard-to-debug errors if you’re not careful.

We also used to spend a lot of time discussing cold starts and lifecycle timeouts, as they could lead to noticeable latency. However, with the maturity of features like AWS SnapStart for Java, this is now a largely solved problem. When designed correctly, cold starts are practically unnoticeable for most use cases.

Advanced AWS Lambda Capabilities

Once you've mastered the basics, you can start leveraging some of Lambda's more advanced capabilities to build complex architectures.

One powerful feature of AWS Lambda is the ability to link functions together using AWS Step Functions. This allows you to execute Lambda functions sequentially, passing data between them as needed. By using Step Functions, you can create complex workflows that can help you to avoid time-outs and the accompanying unclear error messages.

For example, let's say you have a function that needs to perform several tasks in order. By using Step Functions, you can break these tasks down into separate functions and link them together, ensuring that each one completes before the next one starts. If one of the tasks fails, the entire workflow will fail, allowing you to easily identify and fix the problem when coupled with error handling logic like retries and dead queues.

Another important capability of AWS Lambda is logging. AWS provides a logging service called CloudWatch that allows you to monitor and troubleshoot your Lambda functions. By logging important events and errors, you can gain insight into how your functions are performing and quickly identify any issues that may arise.

In addition, debugging can be more challenging with serverless architectures, but Amazon has developed an AWS Toolkit that allows you to debug serverless code locally using debugging tools like breakpoints. No more complicated interfaces: you’ll be able to troubleshoot your code right from your IDE.

Lastly, it's important to consider security when building serverless applications. If you want to stay within the AWS ecosystem, you can use Cognito, which provides user authentication, authorisation, and user management for web and mobile apps. By integrating Cognito with your Lambda functions, you can encrypt and secure user data and ensure that only authorised users can access your application.

‍

Conclusion

Serverless computing with AWS Lambda offers undeniable benefits, from automatic scaling to pay-per-use pricing. By following best practices and using tools like AWS Step Functions, you can build scalable and efficient architectures for event-driven processes, webhooks, and data transformations.

While it has limitations for legacy applications or very long-running tasks, the benefits far outweigh them. This makes Lambda an essential tool in any modern developer's toolkit.