Now in active development — Apache 2.0

Build & Ship SaaS on AWS
in Minutes

A modular TypeScript framework for founders who want full control without the boilerplate. File-based routing, intent-based infrastructure, auth, billing, AI — all wired up.

Get StartedRead the Docs
$npx@venturekit/cli init my-saas
vk.config.ts
import { defineVenture } from '@venturekit/infra';

export default defineVenture({
base: { name: 'my-saas', region: 'us-east-1' },
envs: { dev: { preset: 'nano' }, prod: { preset: 'medium' } },
infrastructure: {
databases: [{ id: 'main', type: 'postgres' }],
auth: [{ id: 'users', signInWith: ['email'] }],
storage: [{ id: 'uploads', cdn: true }],
},
});

Built on battle-tested technologies

TypeScriptLanguage
AWS CDKInfrastructure
LambdaCompute
API GatewayNetworking
CognitoAuth
RDSDatabase
S3Storage
CloudFrontCDN
RedisCache
SESEmail
OpenAIAI
BedrockAI
TypeScriptLanguage
AWS CDKInfrastructure
LambdaCompute
API GatewayNetworking
CognitoAuth
RDSDatabase
S3Storage
CloudFrontCDN
RedisCache
SESEmail
OpenAIAI
BedrockAI
Why VentureKit

Beyond manual setup. Beyond vibe coding.

AI can generate code, but it can't architect production systems. VentureKit gives you battle-tested patterns that actually scale.

Manual Setup

Weeks of glue code

  • Write CDK constructs from scratch
  • Configure API Gateway manually
  • Set up Cognito user pools & flows
  • Wire Lambda + VPC + RDS networking
  • Build auth middleware layer
  • Implement file-based routing yourself
  • Manage environment configs per stage
  • Build billing and subscription logic
2–4 weeks of setup

Vibe Coding

Fast start, fragile result

  • AI generates plausible-looking codeNo architecture
  • Works in demo, breaks in productionFragile
  • No consistent patterns across filesUnmaintainable
  • Hallucinated AWS configs & permissionsInsecure
  • Debugging AI-generated infra at 2 AMCostly
  • Every prompt rebuilds from scratchNo reuse
  • No upgrade path as you scaleDead end
Fast to start, painful to maintain

With VentureKit

Minutes to production

  • Define intents in vk.config.ts2 min
  • Drop route files in src/routes/seconds
  • Add auth with signInWith: ['email']1 line
  • Run vk dev for local Postgres + Redis1 cmd
  • Run vk deploy for full AWS stack1 cmd
  • Scale from nano to large with one word1 word
// Your entire infra in one config
preset: 'micro',
databases: [{ type: 'postgres' }]
Under 5 minutes to deploy
Features

Everything you need to ship fast

A complete toolkit for building production-ready SaaS APIs on AWS. No glue code, no boilerplate — just your business logic.

src/routes/
├── health/
└── get.ts → GET /health
├── projects/
├── post.ts → POST /projects
└── [id]/
├── get.ts → GET /projects/:id
└── delete.ts → DELETE /projects/:id

File-Based Routing

Drop a TypeScript file in src/routes/ and it becomes an API endpoint. GET, POST, PUT, DELETE — auto-discovered from filenames.

infrastructure: {
databases: [{
type: 'postgres',
size: 'medium'
}],
storage: [{ cdn: true }],
caches: [{ type: 'redis' }]
}

Intent-Based Infrastructure

Declare what you need, not how to build it. VentureKit translates your intents into optimized AWS CDK constructs automatically.

nano
~$5–15/mo
micro
~$30–80/mo
medium
~$100–300/mo
large
~$500+/mo

Environment Presets

Go from nano to large with a single word. Each preset configures Lambda memory, timeouts, rate limits, and VPC settings for you.

// Public endpoint
handler(async (body, ctx, log) => {
return { status: 'ok' }
});

// Authenticated endpoint
handler(fn, { scopes: ['api.write'] });

Unified Handler

One handler function adapts to context. No scopes means public, with scopes means authenticated. Status codes auto-detected from HTTP method.

Cognito Auth
Users, Roles, Sessions
Billing
Subscriptions, Invoicing
RBAC & Scopes
Fine-grained permissions

Built-in Auth & Billing

Cognito user pools, RBAC, sessions, subscription management, invoicing, usage tracking, and feature gating — all pre-configured.

import { createAgent } from '@venturekit-pro/ai'

const agent = createAgent({
model: 'gpt-4',
tools: [searchDocs, createTicket],
vectorStore: 'pinecone'
})

AI & RAG Built-in

Embeddings, vector stores, RAG pipelines, and agents with tool use. Works with OpenAI and AWS Bedrock out of the box. Available in VentureKit Pro.

const stripe = apiClient({
baseUrl: 'https://api.stripe.com/v1',
onRequest: [auth.interceptor()],
retry: { maxRetries: 3 }
})

const customer = await stripe.post('/customers')

Third-Party Integrations

Call any external API with built-in retry, OAuth2 token management, and API key handling from env, SSM, or Secrets Manager. One import, zero boilerplate.

// Cross-project call + auto circuit breaker
const invoice = await invoke(
{ function: 'charge', project: 'billing' },
{
payload: { orderId },
fallback: { statusCode: 503, data: null }
}
)

Resilient Microservices

Call functions across projects with one line. Built-in circuit breaker protects against cascading failures — just add a fallback param.

// Works in handler() AND taskHandler()
const timing: Middleware = {
name: 'timing',
fn: async (ctx, next) => {
const start = Date.now()
const res = await next()
return res
}
}

Unified Middleware

Write middleware once, use it everywhere. The same middleware works for HTTP routes, cron jobs, queue handlers, and standalone functions.

Architecture

Layers that just work

Write your business logic at the top. VentureKit handles everything below — from runtime to infrastructure to AWS deployment.

Your Code

Routes, handlers, business logic

You write this
src/routes/vk.config.tsconfig/*.ts

VentureKit Runtime

Framework layer

VentureKit handles
AuthBillingAI / RAGStorageTenancyData

VentureKit Infra

Intent → CDK translation

VentureKit handles
LambdaAPI GatewayCognitoRDSS3 + CDNRedis

AWS

Cloud infrastructure

us-east-1eu-west-1ap-southeast-1

AWS Services — Auto-provisioned

Lambda
Serverless compute
API Gateway
HTTP & WebSocket
RDS
PostgreSQL / MySQL
S3
Object storage
Cognito
Authentication
CloudFront
CDN distribution
ElastiCache
Redis caching
SQS
Message queues
Request Flow
Client→API GW→Lambda→Handler→RDS/S3
How It Works

From zero to production in three steps

01Scaffold

One command generates your project with configs, routes directory, and all the boilerplate handled.

  • TypeScript project ready to go
  • Environment presets pre-configured
  • File-based routing set up
terminal
❯npx @venturekit/cli init my-saas
✓ Created project structure
✓ Generated config files
✓ Installed dependencies
✓ Ready! Run 'vk dev' to start developing
02Develop

Local development server with hot reload, Docker Compose for Postgres/Redis/MinIO — all running locally.

  • Hot-reload with jiti
  • Local Postgres, Redis, S3
  • Lambda-mimicking HTTP server
terminal
❯vk dev
◉ Starting Docker containers...
✓ Postgres running on :5432
✓ Redis running on :6379
✓ Server ready at http://localhost:3000
03Deploy

Your intents become real AWS infrastructure via CDK. Lambda, API Gateway, RDS, S3, Cognito — all provisioned.

  • AWS CDK under the hood
  • Zero AWS config needed
  • Multi-environment support
terminal
❯vk deploy
◉ Synthesizing CDK stack...
✓ Lambda functions deployed
✓ API Gateway configured
✓ RDS instance provisioned
✓ Live at https://api.my-saas.com
Packages

Modular by design

A growing collection of focused packages across two scopes. Open-source core under @venturekit, advanced capabilities under @venturekit-pro. Use what you need, ignore the rest.

Open Source — @venturekit/*

core

Types, presets, config resolution, validation

@venturekit/core
runtime

Handlers, unified middleware, logging, OpenAPI, tracing, invoke with circuit breaker

@venturekit/runtime
infra

CDK constructs, intent translation, deployment

@venturekit/infra
cli

Scaffolding, dev server, deploy, code generation

@venturekit/cli
auth

Cognito, RBAC, sessions, OAuth scopes

@venturekit/auth
data

RDS config, migrations, query utilities, transactions

@venturekit/data
integrations

Third-party API client, OAuth2, API key management, retry & circuit breaker

@venturekit/integrations
storage

S3 config, CDN, lifecycle policies

@venturekit/storage

Pro — @venturekit-pro/*

tenancy

Multi-tenant isolation, routing, quotas, white-label

@venturekit-pro/tenancy
ai

Embeddings, RAG, agents, vector stores, context-aware AI

@venturekit-pro/ai
billing

Subscriptions, invoicing, usage tracking, feature gating

@venturekit-pro/billing
comms

Email, SMS, push notifications, real-time chat, broadcast

@venturekit-pro/comms
$npm install@venturekit/core @venturekit/runtime @venturekit/infra
Presets

Scale with a single word

Each preset configures your entire AWS stack — Lambda memory, timeouts, rate limits, VPC, and data safety. Override any setting per environment.

Start Here
freeExplore
$0

Try VentureKit locally with no AWS account needed. Full framework, zero cost.

  • Local dev server
  • Docker Compose stack
  • Postgres + Redis + MinIO
  • Hot reload
  • All packages available
nanoPrototype
~$5–15/mo AWS

Ideal for prototyping and early-stage MVPs with minimal AWS footprint.

  • 128 MB Lambda
  • 10s timeout
  • 10 req/s rate limit
  • No VPC
  • Relaxed data safety
microDevelopment
~$30–80/mo AWS

For startups with real users and growing traffic. VPC-enabled for security.

  • 256 MB Lambda
  • 10s timeout
  • 50 req/s rate limit
  • VPC enabled
  • Standard data safety
mediumProduction
~$100–300/mo AWS

Production workloads with higher memory, longer timeouts, and strict safety.

  • 512 MB Lambda
  • 15s timeout
  • 100 req/s rate limit
  • VPC enabled
  • Strict data safety
largeHigh-Performance
~$500+/mo AWS

Maximum performance for demanding applications with high concurrency needs.

  • 1024 MB Lambda
  • 30s timeout
  • 500 req/s rate limit
  • VPC enabled
  • Strict data safety

Costs shown are estimated AWS infrastructure costs, not VentureKit pricing. VentureKit is open source under Apache 2.0. You can override any preset value per environment.

// Switch preset per environment
envs: {
local: { preset: 'free' },
dev: { preset: 'nano' },
staging: { preset: 'micro' },
prod: { preset: 'medium' }
};

Ready to build your next SaaS?

Stop wiring together AWS services by hand. VentureKit gives you the full stack — from routing to billing — so you can focus on what makes your product unique.

Start BuildingRead the Docs
$npx@venturekit/cli init my-saas