Effortless AWS

Effortless AWS Deploy in seconds API, database, queues — one deploy Zero infrastructure code Just TypeScript

Export handlers, deploy to AWS. No infrastructure files needed.

Getting Started →

Ship the whole product

API, database, queues, email, website — one project, one deploy, automatic IAM wiring.

Deploy in seconds

Direct AWS API calls. No CloudFormation, no state files. Full deploy in ~5-10 seconds.

Type safety everywhere

Define a table once — get typed clients, typed streams, and runtime validation automatically.

Serverless by default

Pay per use, scale to zero, multi-AZ redundancy. Nothing runs when nobody is using your product.

Everything a product needs

Your product needs	Effortless handler	AWS resources created
REST API	defineApi	Lambda + Function URL + IAM
Database	defineTable	DynamoDB + optional stream Lambda
Background jobs	defineFifoQueue	SQS FIFO + consumer Lambda
File storage	defineBucket	S3 + optional event Lambda
Transactional email	defineMailer	SES + DKIM identity
Website / SSR app	defineApp	CloudFront + Lambda + S3
Static site / SPA	defineStaticSite	CloudFront + S3

All in the same project, all deployed with one command, all with automatic IAM wiring between them.

All definitions

Build a todo app

Each tab adds a layer — every export creates real AWS infrastructure.

todo.ts

Type and schema — shared across handlers.

src/todo.ts

import { z } from "zod";

export type Todo = { id: string; title: string; done: boolean };

export const Command = z.discriminatedUnion("action", [
  z.object({ action: z.literal("create"), title: z.string() }),
  z.object({ action: z.literal("done"), id: z.string(), done: z.boolean() }),
]);

HTTP API

One export — one API. Chained .get() routes handle queries, .post() handles commands.

src/api.ts

import { defineApi } from "effortless-aws";
import { todos } from "./db";
import { Command } from "./todo";

export const todoApi = defineApi({
  basePath: "/todos",
  deps: () => ({ todos }),
})
  .setup(({ deps }) => ({ todos: deps.todos }))
  .get("/", async ({ todos }) => ({
    status: 200,
    body: await todos.query({ pk: "TODO" }),
  }))
  .get("/{id}", async ({ req, todos }) => {
    const todo = await todos.get({ pk: "TODO", sk: req.params.id });
    if (!todo) return { status: 404, body: { error: "Not found" } };
    return { status: 200, body: todo.data };
  })
  .post("/", async ({ input, todos }) => {
    const data = Command.parse(input);
    if (data.action === "create") {
      const id = crypto.randomUUID();
      await todos.put({
        pk: "TODO", sk: id,
        data: { id, title: data.title, done: false },
      });
      return { status: 201, body: { id } };
    }
    await todos.update(
      { pk: "TODO", sk: data.id },
      { set: { done: data.done } },
    );
    return { status: 200, body: { id: data.id, done: data.done } };
  });

Database + stream

Define a table — get a typed client. onRecord fires a stream Lambda on every change. config reads secrets from SSM at cold start.

src/db.ts

import { defineTable, typed, param } from "effortless-aws";
import type { Todo } from "./todo";

export const todos = defineTable({
  schema: typed<Todo>(),
  config: { slackUrl: param("slack/webhook") },
  onRecord: async ({ record, config }) => {
    if (record.eventName === "MODIFY" && record.new?.data.done) {
      await fetch(config.slackUrl, {
        method: "POST",
        body: JSON.stringify({ text: `Done: ${record.new.data.title}` }),
      });
    }
  },
});

Deploy

$ eff deploy

Deployed 2 handler(s) in 6s:
  [table] todos    arn:aws:dynamodb:eu-west-1:***:table/todo-app-dev-todos
  [api]   todoApi  https://abc123.lambda-url.eu-west-1.on.aws/todos

Need a separate environment? Add --stage:

$ eff deploy --stage prod

Deployed 2 handler(s) in 6s:
  [table] todos    arn:aws:dynamodb:eu-west-1:***:table/todo-app-prod-todos
  [api]   todoApi  https://xyz789.lambda-url.eu-west-1.on.aws/todos

Fully isolated infrastructure — separate tables, Lambdas, Function URLs. No shared state between stages.

See how Effortless compares to SST, Nitric, Serverless Framework, and others — detailed comparisons.