SvelteKit

Deploy SvelteKit on AWS

The fastest way to build Svelte apps with file-based routing and SSR.

svelte.dev/docs/kit

Deploy your SvelteKit applications to AWS using Thunder. Choose the pattern that fits your app’s needs.

Available Patterns

Static

S3 + CloudFront

Fargate

Fargate + ALB

Serverless

Lambda + S3 + CloudFront

Prerequisites

Getting Started

Create Project

Scaffold a new SvelteKit project using your preferred package manager. This sets up the project structure, installs dependencies, and prepares you for development.

Terminal window
bunx sv create my-sveltekit-app
cd my-sveltekit-app

Install Thunder

Add Thunder as a development dependency. It provides the CDK constructs you’ll use to define your AWS infrastructure.

Terminal window
bun add @thunder-so/thunder --development

SvelteKit Static Site Deployment

Deploy a fully pre-rendered SvelteKit site to S3 with CloudFront as the CDN. This pattern supports both SSG (pre-rendered pages) and SPA mode (client-side routing with a single HTML shell). No server required.

Configure

Install the static adapter and configure SvelteKit to use it. Then enable prerendering globally by setting prerender = true in your root layout.

Terminal window
bun add -D @sveltejs/adapter-static
svelte.config.js
import adapter from '@sveltejs/adapter-static';


export default {
  kit: {
    adapter: adapter(),
  },
};
src/routes/+layout.ts
export const prerender = true;

Stack

The Static construct provisions an S3 bucket, a CloudFront distribution, and optionally a Route53 DNS record. SvelteKit’s static adapter outputs to build/ by default.

stack/prod.ts
import { Cdk, Static, type StaticProps } from '@thunder-so/thunder';


const config: StaticProps = {
  env: { account: 'YOUR_ACCOUNT_ID', region: 'us-east-1' },
  application: 'myapp',
  service: 'web',
  environment: 'prod',
  rootDir: '.',
  outputDir: 'build',
};


new Static(new Cdk.App(), `${config.application}-${config.service}-${config.environment}-stack`, config);

Deploy

Build your SvelteKit site first, then deploy with CDK. CDK uploads the static files to S3 and provisions the CloudFront distribution.

Terminal window
bun run build
npx cdk deploy --app "bunx tsx stack/prod.ts" --profile default

After deployment, CDK outputs a CloudFront URL where your static site is live.

SvelteKit Containerized Deployment with Fargate

Run your SvelteKit app as a Node.js server inside a Docker container on ECS Fargate. Traffic is routed through an Application Load Balancer. This pattern supports full SSR, API routes, and any server-side logic.

Configure for Node Server

Install the Node adapter and configure SvelteKit to use it. This produces a standard Node.js HTTP server in build/ that can run inside a container.

Terminal window
bun add -D @sveltejs/adapter-node
svelte.config.js
import adapter from '@sveltejs/adapter-node';


export default {
  kit: {
    adapter: adapter(),
  },
};

Stack

The Fargate construct creates an ECS cluster, a Fargate task definition, and an Application Load Balancer.

stack/prod.ts
import { Cdk, Fargate, type FargateProps } from '@thunder-so/thunder';


const config: FargateProps = {
  env: { account: 'YOUR_ACCOUNT_ID', region: 'us-east-1' },
  application: 'myapp',
  service: 'web',
  environment: 'prod',
  rootDir: '.',
  serviceProps: {
    dockerFile: 'Dockerfile',
    architecture: Cdk.aws_ecs.CpuArchitecture.ARM64,
    cpu: 512,
    memorySize: 1024,
    port: 3000,
    desiredCount: 1,
    healthCheckPath: '/',
  },
};


new Fargate(new Cdk.App(), `${config.application}-${config.service}-${config.environment}-stack`, config);

Dockerfile

Create a Dockerfile in your project root. The multi-stage build keeps the final image lean by separating the build environment from the runtime.

Dockerfile
FROM oven/bun:latest AS builder
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun run build


FROM oven/bun:latest AS runner
WORKDIR /app
ENV NODE_ENV=production
ENV HOST=0.0.0.0
ENV PORT=3000
COPY --from=builder /app/build ./build
COPY --from=builder /app/package.json ./
EXPOSE 3000
CMD ["bun", "./build/index.js"]

Environment Variables and Secrets

Runtime environment variables are injected into the Fargate task at deploy time. For sensitive values, store them in AWS Secrets Manager and reference them by ARN — Thunder fetches and injects them automatically.

stack/prod.ts
const config: FargateProps = {
  // ...
  serviceProps: {
    // ...
    variables: [
      { NODE_ENV: 'production' },
    ],
    secrets: [
      {
        key: 'DATABASE_URL',
        resource: 'arn:aws:secretsmanager:us-east-1:123456789012:secret:/myapp/DATABASE_URL-abc123',
      },
    ],
  },
};

Deploy

CDK builds the Docker image, pushes it to ECR, and deploys it to Fargate. No manual Docker commands needed.

Terminal window
npx cdk deploy --app "bunx tsx stack/prod.ts" --profile default

After deployment, CDK outputs the Load Balancer DNS for your application.

SvelteKit Serverless Fullstack Deployment

Deploy SvelteKit with SSR using AWS Lambda for server-side rendering, S3 for static assets, and CloudFront to unify both behind a single domain. This pattern scales to zero and charges only for actual requests.

Install Adapter for Lambda

The @foladayo/sveltekit-adapter-lambda package adapts SvelteKit’s build output to the Lambda function handler format expected by API Gateway.

Terminal window
bun add -D @foladayo/sveltekit-adapter-lambda

Configure SvelteKit for AWS Lambda

Replace the adapter in your SvelteKit config. The serveStatic: true option is required — it tells the adapter to serve prerendered pages directly from the Lambda handler rather than expecting a separate static file server.

svelte.config.js
import adapter from '@foladayo/sveltekit-adapter-lambda';


export default {
  kit: {
    adapter: adapter({
      serveStatic: true,
    }),
  },
};

The build will produce a flat build/ directory (Lambda handler) and build/client/ (static assets for S3).

Stack (Zip mode)

The SvelteKit construct wires up Lambda, API Gateway, S3, and CloudFront automatically. By default, Thunder packages your Lambda handler as a Zip deployment — the fastest option for most apps.

stack/prod.ts
import { Cdk, SvelteKit, type SvelteKitProps } from '@thunder-so/thunder';


const config: SvelteKitProps = {
  env: { account: 'YOUR_ACCOUNT_ID', region: 'us-east-1' },
  application: 'myapp',
  service: 'web',
  environment: 'prod',
  rootDir: '.',
};


new SvelteKit(new Cdk.App(), `${config.application}-${config.service}-${config.environment}-stack`, config);

Container Mode

Zip deployments have a 250 MB unzipped size limit. If your app has large dependencies — native modules, ML libraries, or heavy assets — switch to container mode. Thunder builds a Docker image, pushes it to ECR, and deploys it as a container Lambda, which supports up to 10 GB.

Stack (Container mode)

Add dockerFile to serverProps to enable container mode.

stack/prod.ts
const config: SvelteKitProps = {
  // ...
  serverProps: {
    dockerFile: 'Dockerfile',
    memorySize: 2048,
  },
};

Dockerfile

Dockerfile
FROM public.ecr.aws/lambda/nodejs:22


# Copy all lambda files
COPY . ./


CMD ["index.handler"]

Environment Variables and Secrets

Runtime environment variables are injected into the Lambda function at deploy time. For sensitive values, store them in AWS Secrets Manager and reference them by ARN — Thunder fetches and injects them automatically.

stack/prod.ts
const config: SvelteKitProps = {
  // ...
  serverProps: {
    variables: [
      { NODE_ENV: 'production' },
    ],
    secrets: [
      {
        key: 'DATABASE_URL',
        resource: 'arn:aws:secretsmanager:us-east-1:123456789012:secret:/myapp/DATABASE_URL-abc123',
      },
    ],
  },
};

Deploy

Build your SvelteKit app first to generate the Lambda handler and static assets, then deploy with CDK.

Terminal window
bun run build
npx cdk deploy --app "bunx tsx stack/prod.ts" --profile default

After deployment, CDK outputs a CloudFront URL that serves both your SSR responses and static assets.