npx sst@latest create my-app
cd my-app
npm install

// sst.config.ts — TypeScript infrastructure configuration
/// <reference path="./.sst/platform/config.d.ts" />

export default $config({
  app(input) {
    return {
      name: "my-saas-app",
      removal: input?.stage === "production" ? "retain" : "remove",
      home: "aws",
    };
  },

  async run() {
    // S3 bucket
    const bucket = new sst.aws.Bucket("UserAssets", {
      public: true,  // Public read
    });

    // RDS PostgreSQL
    const database = new sst.aws.Postgres("AppDatabase", {
      scaling: {
        min: "0 ACU",   // Scale to zero when idle
        max: "4 ACU",
      },
    });

    // Function with resource bindings
    const api = new sst.aws.Function("ApiHandler", {
      handler: "src/api/handler.handler",
      link: [bucket, database],  // Automatic type-safe bindings
      environment: {
        STAGE: $app.stage,
      },
    });

    // API Gateway
    new sst.aws.ApiGatewayV2("Api", {
      routes: {
        "GET /users": api,
        "POST /users": api,
        "GET /users/{id}": api,
      },
    });

    // Next.js app
    new sst.aws.Nextjs("Web", {
      path: "apps/web",
      link: [database, bucket],  // Web app also has type-safe access
    });

    return {
      bucketUrl: bucket.url,
    };
  },
});

// src/api/handler.ts — no hardcoded env vars, type-safe SST Resource
import { Resource } from "sst";
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import { Pool } from "pg";

const s3 = new S3Client({});
const db = new Pool({ connectionString: Resource.AppDatabase.secretArn });

export const handler = async (event: APIGatewayProxyEvent) => {
  // TypeScript knows exactly what's available
  const bucketName = Resource.UserAssets.name;         // string
  const dbArn = Resource.AppDatabase.secretArn;         // string

  await s3.send(new PutObjectCommand({
    Bucket: bucketName,
    Key: "uploads/file.jpg",
    Body: Buffer.from("content"),
  }));

  const { rows } = await db.query("SELECT * FROM users LIMIT 10");

  return {
    statusCode: 200,
    body: JSON.stringify({ users: rows }),
  };
};

# Start live development — Lambda runs locally, invoked by real AWS events
sst dev

# What happens:
# 1. SST deploys a "stub" Lambda to AWS (instant, no code upload)
# 2. When AWS invokes the Lambda, request is forwarded to your local machine
# 3. Your local code executes with full debugger support
# 4. Response is sent back to AWS

# Result: Real API Gateway → Real DynamoDB → Your local Lambda code
# Breakpoints work. console.log streams in real-time.
# No Docker needed. No local Lambda emulation. Real AWS.

npm install -g serverless@v4
serverless create --template aws-nodejs-typescript --path my-service

# serverless.yml
service: my-saas-app

frameworkVersion: "4"

provider:
  name: aws
  runtime: nodejs22.x
  region: us-east-1
  stage: ${opt:stage, 'dev'}
  environment:
    STAGE: ${self:provider.stage}
    DB_URL: ${ssm:/my-app/${self:provider.stage}/db-url}
    S3_BUCKET: ${self:custom.bucketName}

  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - s3:GetObject
            - s3:PutObject
          Resource: !Sub "arn:aws:s3:::${self:custom.bucketName}/*"
        - Effect: Allow
          Action:
            - dynamodb:GetItem
            - dynamodb:PutItem
            - dynamodb:Query
          Resource: !GetAtt UsersTable.Arn

custom:
  bucketName: my-app-${self:provider.stage}-assets
  webpack:
    webpackConfig: webpack.config.js
    includeModules: true

functions:
  getUser:
    handler: src/handlers/user.get
    events:
      - httpApi:
          path: /users/{id}
          method: get

  createUser:
    handler: src/handlers/user.create
    events:
      - httpApi:
          path: /users
          method: post

  processQueue:
    handler: src/handlers/queue.process
    events:
      - sqs:
          arn: !GetAtt UserQueue.Arn
          batchSize: 10

resources:
  Resources:
    UsersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: users-${self:provider.stage}
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: id
            AttributeType: S
        KeySchema:
          - AttributeName: id
            KeyType: HASH

    UserQueue:
      Type: AWS::SQS::Queue
      Properties:
        QueueName: user-queue-${self:provider.stage}

// src/handlers/user.ts
import { APIGatewayProxyHandlerV2 } from "aws-lambda";
import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";

const dynamo = new DynamoDBClient({ region: process.env.AWS_REGION });

export const get: APIGatewayProxyHandlerV2 = async (event) => {
  const userId = event.pathParameters?.id;

  if (!userId) {
    return { statusCode: 400, body: JSON.stringify({ error: "Missing user ID" }) };
  }

  const result = await dynamo.send(new GetItemCommand({
    TableName: `users-${process.env.STAGE}`,
    Key: marshall({ id: userId }),
  }));

  if (!result.Item) {
    return { statusCode: 404, body: JSON.stringify({ error: "User not found" }) };
  }

  return {
    statusCode: 200,
    body: JSON.stringify(unmarshall(result.Item)),
  };
};

# serverless.yml — popular plugins ecosystem
plugins:
  - serverless-esbuild         # TypeScript/ESM bundling
  - serverless-offline         # Local API Gateway emulation
  - serverless-dynamodb-local  # Local DynamoDB for testing
  - serverless-prune-plugin    # Delete old Lambda versions
  - serverless-domain-manager  # Custom domains
  - serverless-lift            # Higher-level constructs (SQS, S3 website)

npm install -g aws-cdk
npm install aws-cdk-lib constructs
cdk init app --language typescript

// lib/my-app-stack.ts
import * as cdk from "aws-cdk-lib";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as apigw from "aws-cdk-lib/aws-apigatewayv2";
import * as integrations from "aws-cdk-lib/aws-apigatewayv2-integrations";
import * as s3 from "aws-cdk-lib/aws-s3";
import * as dynamodb from "aws-cdk-lib/aws-dynamodb";
import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
import { Construct } from "constructs";

export class MyAppStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // S3 bucket
    const bucket = new s3.Bucket(this, "AssetsBucket", {
      bucketName: `my-app-${this.account}-assets`,
      publicReadAccess: false,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true,
    });

    // DynamoDB table
    const usersTable = new dynamodb.Table(this, "UsersTable", {
      partitionKey: { name: "id", type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });

    // Lambda function with automatic bundling
    const apiHandler = new NodejsFunction(this, "ApiHandler", {
      entry: "src/api/handler.ts",
      runtime: lambda.Runtime.NODEJS_22_X,
      environment: {
        USERS_TABLE: usersTable.tableName,
        ASSETS_BUCKET: bucket.bucketName,
        STAGE: this.node.tryGetContext("stage") ?? "dev",
      },
      bundling: {
        minify: true,
        externalModules: ["@aws-sdk/*"],
      },
    });

    // Grant permissions
    usersTable.grantReadWriteData(apiHandler);
    bucket.grantReadWrite(apiHandler);

    // HTTP API
    const api = new apigw.HttpApi(this, "HttpApi", {
      corsPreflight: {
        allowHeaders: ["Content-Type", "Authorization"],
        allowMethods: [apigw.CorsHttpMethod.GET, apigw.CorsHttpMethod.POST],
        allowOrigins: ["https://yourapp.com"],
      },
    });

    const lambdaIntegration = new integrations.HttpLambdaIntegration(
      "ApiIntegration",
      apiHandler
    );

    api.addRoutes({
      path: "/users",
      methods: [apigw.HttpMethod.GET, apigw.HttpMethod.POST],
      integration: lambdaIntegration,
    });

    api.addRoutes({
      path: "/users/{id}",
      methods: [apigw.HttpMethod.GET, apigw.HttpMethod.DELETE],
      integration: lambdaIntegration,
    });

    // Output API URL
    new cdk.CfnOutput(this, "ApiUrl", { value: api.url! });
  }
}

# Bootstrap (once per AWS account/region)
cdk bootstrap aws://ACCOUNT_ID/us-east-1

# Synthesize CloudFormation template
cdk synth

# Compare what will change
cdk diff

# Deploy
cdk deploy --context stage=dev

# Destroy
cdk destroy