The Backend Platform
for TypeScript

Build production APIs with databases, queues, and storage built into the platform. Deploy to the edge in minutes.

Everything you need for backend development—in one platform.

Zero Config Files

No configuration files. No infrastructure setup. Just TypeScript. Stack Deploy includes databases, queues, caching, and storage built directly into the platform. Import what you need and deploy.

Global Edge Deployment

Your API runs on a global edge network in 275+ cities worldwide. Sub-50ms response times for users anywhere. No regions to configure.

Just TypeScript

No cloud certifications. No DevOps knowledge required. If you've built with Express or Next.js, you already know Stack Deploy.

Simple, Predictable Pricing

Pay only for requests and compute time. No bandwidth fees. No per-seat charges. No surprise bills. One simple line item.

The Same API. Minutes Instead of Hours.

Traditional cloud platforms require hours of infrastructure setup. Stack Deploy gives you everything built into the platform.

Traditional Setup

2-4 hours

What you need to configure:

// 1. Create Lambda function in AWS Console
// 2. Configure API Gateway + routes + CORS
// 3. Create DynamoDB table with correct schema
// 4. Create SQS queue with permissions
// 5. Set up IAM roles + policies for each service
// 6. Configure environment variables
// 7. Set up CloudWatch logs
// 8. Configure VPC (if using RDS)

// Then write your function:
const AWS = require('aws-sdk')
const dynamodb = new AWS.DynamoDB.DocumentClient()
const sqs = new AWS.SQS()

exports.handler = async (event) => {
  try {
    // Parse API Gateway event
    const body = JSON.parse(event.body)
    
    // DynamoDB put item
    const params = {
      TableName: process.env.TABLE_NAME,
      Item: {
        id: Date.now().toString(),
        userId: body.userId,
        total: body.total
      }
    }
    
    await dynamodb.put(params).promise()
    
    // Send to SQS
    await sqs.sendMessage({
      QueueUrl: process.env.QUEUE_URL,
      MessageBody: JSON.stringify(params.Item)
    }).promise()
    
    // Return API Gateway response format
    return {
      statusCode: 200,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ id: params.Item.id })
    }
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: error.message })
    }
  }
}

// Plus: IAM policies, deployment configs, monitoring setup...

Stack Deploy

5 minutes

main.ts

import { app, db, queue } from '@stackdeploy/runtime'

// Define infrastructure
const mainDb = db('main')
const ordersQueue = queue('orders')

// Create app
const api = app({
  db: [mainDb],
  queue: [ordersQueue]
})

// Define handler
api.post('/v1/orders', async (ctx) => {
  const order = await ctx.req.json()
  
  // Save to database
  const result = await ctx.db.main.query(
    'INSERT INTO orders (user_id, total) VALUES (?, ?)',
    [order.userId, order.total]
  )
  
  // Queue for processing
  await ctx.queue.orders.send({
    ...order,
    id: result.insertId
  })
  
  return ctx.res.json({ id: result.insertId })
})

export default api

Save hours on infrastructure. Save money on bandwidth. Deploy in minutes.

Write Code. Deploy Globally. That's It.

Stack Deploy includes everything you need for production APIs built into the platform. Databases, queues, and WebSockets with zero configuration. Just TypeScript.

main.ts

import { app, db, queue } from '@stackdeploy/runtime'

// Define your infrastructure
const mainDb = db('main')
const ordersQueue = queue('orders')

// Create your API
const api = app({ db: [mainDb], queue: [ordersQueue] })

// Define middleware
const auth = async (ctx, next) => {
  if (!ctx.req.headers.get('authorization'))
    return ctx.res.json({ error: 'Unauthorized' }, 401)
  return next()
}

// Add routes with handlers
api.post('/orders', auth, async (ctx) => {
  const order = await ctx.req.json()
  
  // Save to database
  const result = await ctx.db.main.query(
    'INSERT INTO orders (user_id, total) VALUES (?, ?)',
    [order.userId, order.total]
  )
  
  // Queue for processing
  await ctx.queue.orders.send({ id: result.insertId, ...order })
  
  return ctx.res.json({ id: result.insertId })
})

// Export and deploy globally
export default api

Framework Primitives. Platform Infrastructure.

Import db(), queue(), kv(), storage(), or realtime() and they're ready to use instantly. Complete backend infrastructure built into the platform. Zero config.

Key-Value Store

Built-in

Lightning-fast edge storage for caching and session data

handlers/products.ts

import { app, kv } from '@stackdeploy/runtime'

const cache = kv('cache')
const api = app({ kv: [cache] })

api.get('/product/:id', async (ctx) => {
  // Check cache first
  const cached = await ctx.kv.cache.get(ctx.params.id)
  if (cached) return ctx.res.json(cached)
  
  // Fetch and cache
  const product = await fetchFromDB(ctx.params.id)
  await ctx.kv.cache.set(ctx.params.id, product)
  
  return ctx.res.json(product)
})

Message Queues

Built-in

Reliable background jobs and batch processing

workers/emails.ts

import { app, queue } from '@stackdeploy/runtime'

const emails = queue('emails')
const api = app({ queue: [emails] })

// Send email to queue
api.post('/signup', async (ctx) => {
  await ctx.queue.emails.send({
    type: 'welcome', to: 'user@example.com'
  })
})

// Process the queue
api.queue('emails', async (ctx) => {
  await sendgrid.send(ctx.job)
})

Realtime Connections

Built-in

WebSockets for chat, notifications, and multiplayer

handlers/chat.ts

import { app, realtime } from '@stackdeploy/runtime'

const chat = realtime('chat')
const api = app({ realtime: [chat] })

api.post('/message', async (ctx) => {
  const { roomId, message } = await ctx.req.json()
  
  // Broadcast to all connected clients
  await ctx.realtime.chat.broadcast(`room:${roomId}`, {
    type: 'message',
    content: message
  })
})

SQL Database

Built-in

Full relational database at the edge with migrations

handlers/users.ts

import { app, db } from '@stackdeploy/runtime'

const mainDb = db('main')
const api = app({ db: [mainDb] })

api.post('/users', async (ctx) => {
  const data = await ctx.req.json()
  
  const user = await ctx.db.main.transaction(async (tx) => {
    // Create user
    const user = await tx.query(
      'INSERT INTO users (email) VALUES (?)',
      [data.email]
    )
    
    // Create profile
    await tx.query(
      'INSERT INTO profiles (user_id) VALUES (?)',
      [user.id]
    )
    
    return user
  })
  
  return ctx.res.json(user)
})

Blob Storage

Built-in

Store files, images, and videos with global CDN—no S3 buckets to configure

handlers/uploads.ts

import { app, storage } from '@stackdeploy/runtime'

const avatars = storage('avatars')
const api = app({ storage: [avatars] })

api.post('/upload', async (ctx) => {
  const formData = await ctx.req.formData()
  const file = formData.get('avatar')
  
  // Upload to storage
  const url = await ctx.storage.avatars
    .put(`user-${userId}.jpg`, file)
  
  return ctx.res.json({ url })
})

Use Our Services or Bring Your Own

Stack Deploy is TypeScript running on the edge. Use our built-in services for simplicity, or bring any npm package and connect to your own infrastructure.

Built-in Services

Fastest

Import databases, queues, and storage directly from the platform. Zero configuration.

main.ts

import { app, db, queue } from '@stackdeploy/runtime'

const mainDb = db('main')
const jobs = queue('jobs')

const api = app({
  db: [mainDb],
  queue: [jobs]
})

api.post('/users', async (ctx) => {
  // Use managed database
  const user = await ctx.db.main.query(
    'INSERT INTO users VALUES (?)',
    [email]
  )
  
  // Queue background job
  await ctx.queue.jobs.send({
    type: 'welcome-email',
    userId: user.id
  })
  
  return ctx.res.json({ user })
})

Instant setup - no configuration

Global edge deployment

Included in platform pricing

Bring Your Own

Maximum Flexibility

Use any npm package. Connect to existing databases, Redis, Kafka, or any service.

main.ts

import { app } from '@stackdeploy/runtime'
import postgres from 'postgres'
import { createClient } from 'redis'

// Your Postgres database
const sql = postgres(process.env.DATABASE_URL)

// Your Redis instance
const redis = createClient({
  url: process.env.REDIS_URL
})

const api = app()

api.post('/users', async (ctx) => {
  // Your database
  const [user] = await sql`
    INSERT INTO users (email)
    VALUES ${email} RETURNING *
  `
  
  // Your Redis cache
  await redis.set(
    `user:${user.id}`,
    JSON.stringify(user)
  )
  
  return ctx.res.json({ user })
})

Use existing infrastructure

Any npm package works

No vendor lock-in

Hybrid Approach

Best of Both

Mix and match built-in services with your own infrastructure. Use our edge cache with your existing database, or connect to Stripe and Resend while using our queue system.

api.ts

import { app, kv, queue } from '@stackdeploy/runtime'
import postgres from 'postgres'
import Stripe from 'stripe'

// Built-in edge cache and queue
const cache = kv('cache')
const jobs = queue('jobs')

// Your existing database and Stripe
const sql = postgres(process.env.DATABASE_URL)
const stripe = new Stripe(process.env.STRIPE_KEY)

const api = app({ kv: [cache], queue: [jobs] })

api.post('/checkout', async (ctx) => {
  // Check edge cache first
  const cached = await ctx.kv.cache.get('products')
  
  // Create Stripe checkout
  const session = await stripe.checkout.sessions.create({
    line_items: items, mode: 'payment'
  })
  
  // Save to your database
  const [order] = await sql`
    INSERT INTO orders (session_id, total)
    VALUES ${session.id}, ${total} RETURNING *
  `
  
  // Queue fulfillment job
  await ctx.queue.jobs.send({ type: 'fulfill', orderId: order.id })
  
  return ctx.res.json({ url: session.url })
})

Monitor & Debug in Real-Time

Built-in analytics, logs, and performance monitoring. Understand your API's behavior without third-party tools.

Real-Time Logs

Stream logs from your edge functions in real-time. Debug production issues instantly.

api.ts

api.post('/orders', async (ctx) => {
  // Logs appear in real-time
  console.log('Processing order',
    ctx.req.body)
  
  try {
    const result = await ctx.db.main
      .query('INSERT ...')
    
    console.log('Order created',
      result.insertId)
    
    return ctx.res.json({ result })
  } catch (err) {
    // Errors auto-captured
    console.error('Failed:', err)
    throw err
  }
})

Stream from CLI or dashboard

Filter by deployment or time

Search across all logs

30 days retention included

Performance Metrics

Track request performance, latency, and errors. Understand how your API performs globally.

Request Volume 1.2M/day

P95 Latency 45ms

Error Rate 0.02%

Top Endpoints

POST /orders 38ms

GET /products/:id 15ms

POST /checkout 124ms

P50/P95/P99 percentiles

Geographic latency breakdown

Endpoint-level metrics

Request volume trends

View Everything From Your Terminal

Stream logs, check metrics, and debug errors—all from the CLI

# Tail logs in real-time
$ stackdeploy logs --tail

# Show recent errors
$ stackdeploy errors --last 1h

# Performance summary
$ stackdeploy metrics

Real-time log streaming

Filter and search

Quick metrics overview

Debug from terminal

Error Tracking

Automatic error capture with stack traces. Debug issues without external services.

Recent Errors

TypeError: Cannot read 'id'

at processOrder (api.ts:45)

23 occurrences 18 users

DatabaseConnectionError

at query (runtime.ts:128)

5 occurrences 5 users

Automatic error capture

Full stack traces

Request context included

Group similar errors

Complete Observability Built-In

View logs, metrics, and errors together in one unified dashboard. Everything you need to monitor and debug your applications.

Real-Time Logs

Stream from dashboard or CLI

Performance Metrics

Latency, throughput, and more

Error Tracking

Stack traces and grouping

Built for Speed. Built for Scale.

Stack Deploy combines the best of serverless platforms with complete backend infrastructure built in.

Feature	Stack Deploy	AWS Lambda	Traditional Server	Vercel Functions
Framework model	Import primitives	Manual SDK	N/A	Separate services
Infrastructure from code
Learning curve	Just TypeScript	Weeks to months	Weeks to months	Days
Setup complexity	Zero config	SAM/CDK/Terraform	Docker/K8s	vercel.json
Billing complexity	One simple bill	15+ line items	Custom pricing	Per-seat + usage
Time to first deploy	<5 minutes	2-4 hours	1-2 days	30 minutes
Global latency	<50ms worldwide	100-300ms	200-500ms	50-150ms
Cold starts	0ms (isolates)	50-200ms	N/A	50-250ms
Built-in infrastructure	KV, Queue, DB, Realtime	Separate services	Manual setup	Postgres, Blob, KV
Bring your own services	Any npm package	Yes	Yes	Limited
Vendor lock-in	Portable TypeScript	AWS-specific	None	Platform APIs
DevOps required	None	Heavy	Very Heavy	Minimal
Built-in logs & metrics	Real-time streaming	CloudWatch	Manual setup	Basic logs
Error tracking	Built-in	CloudWatch	Third-party	Limited
Observability	Included	Separate services	Manual setup	Limited

Stop fighting infrastructure. Start shipping features.

Start Building Faster

Join the waitlist for the backend platform built for TypeScript developers. Everything you need—databases, queues, storage—built into the platform. Deploy to the edge in minutes.

The Backend Platformfor TypeScript

Zero Config Files

Global Edge Deployment

Just TypeScript

Simple, Predictable Pricing

The Same API. Minutes Instead of Hours.

Traditional Setup

Stack Deploy

Write Code. Deploy Globally. That's It.

Framework Primitives. Platform Infrastructure.

Key-Value Store

Message Queues

Realtime Connections

SQL Database

Blob Storage

Use Our Services or Bring Your Own

Built-in Services

Bring Your Own

Hybrid Approach

Monitor & Debug in Real-Time

Real-Time Logs

Performance Metrics

View Everything From Your Terminal

Error Tracking

Complete Observability Built-In

Built for Speed. Built for Scale.

Start Building Faster

The Backend Platform
for TypeScript