SST (Serverless Stack): Full-Stack Serverless Framework

Overview

SST is a modern framework for building and deploying full-stack serverless applications. It combines infrastructure-as-code with a local development environment, enabling developers to build, test, and deploy serverless applications efficiently.

Key Features

1. Full-Stack Development

• Frontend and backend in a single codebase
• Unified deployment pipeline
• Shared type definitions between client and server
• Built-in support for React, Vue, Svelte, and other frameworks

2. Local Development

• Live Lambda function reloading
• Local DynamoDB and other AWS service emulation
• Real-time debugging capabilities
• Hot module replacement for frontend

3. Infrastructure as Code

• TypeScript-based infrastructure definitions
• Type-safe resource configuration
• Automatic resource linking and permissions
• Environment-specific deployments

4. Built-in Constructs

• Api: REST and GraphQL APIs
• Function: Lambda functions with automatic permissions
• Table: DynamoDB tables with simplified configuration
• Bucket: S3 buckets with CORS and access control
• Queue: SQS queues for async processing
• Topic: SNS topics for pub/sub messaging
• Auth: Cognito authentication
• RDS: Relational database support

Architecture

┌─────────────────────────────────────┐
│      Frontend (React/Vue/etc)       │
├─────────────────────────────────────┤
│    SST Client SDK (Type-safe)       │
├─────────────────────────────────────┤
│   API Gateway + Lambda Functions    │
├─────────────────────────────────────┤
│  DynamoDB | RDS | S3 | Other AWS    │
└─────────────────────────────────────┘

Project Structure

my-sst-app/
├── sst.config.ts          # Stack configuration
├── stacks/
│   ├── Api.ts             # API definitions
│   ├── Database.ts        # Database setup
│   └── Storage.ts         # S3 buckets
├── packages/
│   ├── core/              # Shared code
│   ├── functions/         # Lambda handlers
│   └── web/               # Frontend app
└── package.json

Core Concepts

1. Stacks

Logical groupings of AWS resources that can be deployed independently:

export function API({ stack }: StackContext) {
  const api = new Api(stack, "api", {
    routes: {
      "GET /notes": "packages/functions/src/list.main",
      "POST /notes": "packages/functions/src/create.main",
    },
  });

  stack.addOutputs({
    ApiEndpoint: api.url,
  });
}

2. Resource Linking

Automatic permission management and environment variable injection:

const table = new Table(stack, "notes", {
  fields: { id: "string" },
  primaryIndex: { partitionKey: "id" },
});

const api = new Api(stack, "api", {
  routes: {
    "GET /notes": "list.main",
  },
});

api.attachPermissions([table]);

3. Type Safety

Automatic type generation for resources:

import { Resource } from "sst";

export const handler = async (event) => {
  const table = Resource.NotesTable;
  // Full TypeScript support for table operations
};

Development Workflow

Local Development

# Start local development environment
npm run dev

# Runs:
# - Frontend dev server with hot reload
# - Lambda functions with live reload
# - Local AWS service emulation

Deployment

# Deploy to AWS
npm run deploy

# Deploy specific stage
npm run deploy -- --stage prod

# Remove stack
npm run remove

Common Use Cases

1. REST API with Database

• Lambda functions handling HTTP requests
• DynamoDB for data persistence
• Automatic CORS configuration

2. Real-time Applications

• WebSocket APIs via API Gateway
• DynamoDB Streams for real-time updates
• SNS/SQS for async processing

3. File Processing

• S3 event triggers
• Lambda for processing
• Results stored in database

4. Authentication & Authorization

• Cognito user pools
• JWT token validation
• Role-based access control

Advantages

✅ Unified Development: Single codebase for frontend and backend
✅ Type Safety: End-to-end TypeScript support
✅ Fast Iteration: Local development with live reload
✅ Cost Effective: Pay-per-use serverless pricing
✅ Scalability: Auto-scaling built-in
✅ Developer Experience: Minimal boilerplate, sensible defaults
✅ AWS Native: Direct access to AWS services

Limitations

❌ Cold starts (mitigated with provisioned concurrency)
❌ Vendor lock-in to AWS
❌ Debugging complexity in production
❌ Limited execution time (15 minutes for Lambda)
❌ Stateless by design

Comparison with Alternatives

Getting Started

# Create new SST project
npm create sst@latest my-app

# Navigate and start development
cd my-app
npm run dev

# Deploy
npm run deploy

Conclusion

SST is ideal for teams building modern, full-stack serverless applications on AWS. It significantly reduces development friction through excellent local development experience, type safety, and sensible defaults, making it one of the best choices for serverless development in 2024.