Why I Built My Own AWS Deployment Tool for Serverless Apps

Why Build Your Own AWS Deployment Tool?

As a software engineer with over 12 years of experience, I have a passion for creating effective tools that solve real problems. My journey with serverless applications on AWS has led me to use the Serverless Framework and AWS CDK. However, I often encountered a frustrating gap between conceptualizing an idea and deploying it in the cloud.

This friction inspired me to build my own AWS deployment tool. My goal was to streamline the deployment process, bypass the complexities of CloudFormation, and enable quicker iterations through direct API calls.

What Frustrations Did I Face with Existing Tools?

Initially, I embraced the Serverless Framework, the industry standard at the time. When AWS CDK emerged, I was hopeful about its promise of “infrastructure as real code.” Yet, I frequently found myself tangled in infrastructure puzzles instead of focusing on shipping features. The repetitive challenges included:

• Splitting stacks for faster Lambda deployment.
• Figuring out bundling configurations.
• Waiting for CloudFormation to process changes, even for minor fixes.

In large projects, these trade-offs might be acceptable. However, for serverless applications that prioritize agility, it felt counterproductive. I wanted a rapid feedback loop: change code, deploy, and see results without the time-consuming overhead of debugging stack configurations.

How Did I Discover a New Approach?

The breakthrough came when I realized that I could create AWS resources directly via the AWS SDK, eliminating the need for CloudFormation. This insight inspired the concept for a new tool that combined Firebase's intuitive code-as-config model with the efficiency of direct AWS SDK calls. What if I could declare my Lambda handler and its configuration in one place? My goal was simplicity and speed, without the burdensome stack definitions and boilerplate code.

What is Effortless-AWS?

I set out to create Effortless-AWS in response to these challenges. To do this effectively, I relied on three key libraries:

1. ts-morph: Analyzes TypeScript's Abstract Syntax Tree (AST) to extract infrastructure information directly from handler code.
2. Effect-TS: Manages complex orchestrations of API calls and error handling efficiently, reducing cognitive load.
3. Typed AWS SDK Wrapper: Provides type safety for AWS SDK errors, ensuring that all possible errors are accounted for at the type level.

With these tools, I envisioned a streamlined API experience. Each handler would be a single function call taking an options object—making it easy to read and extend.

What Does a Simplified Handler Look Like?

Here’s an example of a simple Lambda function using Effortless-AWS:

import { defineHttp } from "effortless-aws";

export const hello = defineHttp({
  method: "GET",
  path: "/hello",
  onRequest: async ({ req }) => ({
    status: 200,
    body: { message: "Hello World!" },
  }),
});

This single file encompasses your Lambda function, its API Gateway route, and IAM role. Just run eff deploy, and it’s live. The previous approach with CDK required multiple files and commands, often feeling cumbersome.

How Does Effortless-AWS Work?

Effortless-AWS operates in four stages during deployment:

1. AST Analysis: Using ts-morph to read your TypeScript source, extracting every defineHttp and defineTable call.
2. Code Compilation: Employing esbuild to compile each handler into a single ESM file, optimizing shared dependencies with Lambda Layers.
3. State Comparison: Checking existing AWS resources against the declared state in your code and applying only the necessary changes.
4. Direct API Calls: Using typed Effect wrappers to create, update, or reconfigure resources, ensuring that all possible errors are accounted for without guesswork.

Currently, the tool is in alpha but has been successfully deployed for real projects, including my documentation website and personal projects utilizing AWS Lambda, DynamoDB, and more.

What’s Next for Effortless-AWS?

My roadmap for Effortless-AWS includes numerous features still in development. The goal is to help developers like you ship faster, allowing you to focus on solving real problems rather than wrestling with infrastructure configurations.

If you're a developer interested in enhancing your AWS deployment experience, I invite you to try Effortless-AWS and share your feedback. Your insights will help shape its future.

Conclusion: Why Build Your Own AWS Deployment Tool?

Building my own AWS deployment tool was a response to the hurdles I faced in serverless application development. By focusing on simplicity, speed, and type safety, I created Effortless-AWS to eliminate the friction between idea and deployment. As it evolves, I hope it empowers developers to ship more effectively and efficiently.

Key Takeaways

• Existing tools like AWS CDK can introduce unnecessary complexity.
• Direct AWS SDK calls streamline deployment processes.
• A unified configuration object enhances readability and type safety.
• Continuous feedback is critical for tool development.
• Effortless-AWS aims to significantly simplify serverless application deployments.