ForkLaunch is a backend framework and infrastructure platform that turns application code into production-grade deployments. One-click SOC 2 compliance, full VPC isolation, zero external vendors beyond your cloud provider, on-premable from day one.
Auth, billing, deployments, monitoring — the kind of setup that usually takes a platform team six months, before you've even written your first feature.
We drop in right alongside the code you're already generating with Lovable, Replit, v0, Cursor, and Claude Code.
Whether you're an engineer shipping a SaaS, a founder spinning up an AI agent, or a builder who just wants their thing to work at scale — we meet you where you are.
Most Node backends fall into one of two buckets:
| Approach | Problem |
|---|---|
| Hand-built Express | Boilerplate, scaling friction, infra drift |
| Full-stack frameworks | Fast at the start, hard to escape, poor infra support |
ForkLaunch gives you a middle path:
- Type-safe Express — Express ergonomics with static typing via Zod or TypeBox
- CLI-generated architecture — Services, workers, and libraries created and wired with a single command
- Infrastructure as code — Auth, database, cache, storage, queues through ergonomic DI
- Auto-generated APIs and SDKs — OpenAPI, AsyncAPI, and typed client SDKs from your route definitions
- Full observability — OpenTelemetry metrics, logs, and traces out of the box
- Incremental adoption — Drop into any existing Express app, no rewrite required
If you don't like it, you can change it. ForkLaunch is designed to stay out of your way.
Host agents, deploy services, and go from "it works on my laptop" to closing enterprise deals — without the infrastructure headache.
- SOC 2 compliance — one-click audit-ready configuration
- VPC isolation — full network isolation per tenant or environment
- Zero vendor lock-in — only your cloud provider, nothing else
- On-prem ready — deploy anywhere from day one
- Auth and billing — built-in identity and payment infrastructure
- Monitoring and observability — metrics, logs, and traces bootstrapped automatically
- Multi-environment deployments — dev, staging, production with consistent tooling
Already powering realtime video, asynchronous document AI parsing, and cloud management across banking, insurance, consumer, and healthcare.
Self-serve is live at forklaunch.com.
npm i -g forklaunchforklaunch init app <app_name>forklaunch init service <service_name>
forklaunch init worker <worker_name>
forklaunch init library <library_name># apply initial migrations and schemas
pnpm/bun database:setup
# start all services
pnpm/bun devEach command adds project files, updates the manifest, registers build and runtime config, and ensures consistent structure across all components.
Drop ForkLaunch into new or existing Express apps:
import { OpenTelemetryCollector } from '@forklaunch/core/http';
import { forklaunchExpress, handlers } from '@forklaunch/express';
import {
number,
optional,
SchemaValidator,
string,
} from '@forklaunch/validator/zod';
const app = forklaunchExpress(
SchemaValidator(),
new OpenTelemetryCollector('my-service')
);
// typed route with auto-generated OpenAPI docs
app.get("/healthz", {
name: "Health Check",
summary: "Returns service health",
responses: { 200: string }
}, (req, res) => {
res.status(200).send("Ok!");
});
// typed body and response with schema validation
const bodySchema = {
something: number,
optionalSomething: optional(string)
};
app.post("/items", {
name: "Create Item",
summary: "Creates an item with a hello: world greeting",
body: bodySchema,
responses: {
200: { ...bodySchema, hello: string }
}
}, (req, res) => {
res.status(200).json({ ...req.body, hello: 'world' });
});
// register handlers for typed SDK generation
app.registerSdks(..);
app.listen(8000, () => {
console.log('Server started on 8000');
});Generated applications share a metrics definition in blueprint/monitoring/metricsDefinitions.ts. The standard HTTP metrics use the same names that are emitted to OpenTelemetry and exposed through Prometheus:
| Metric | Type | Labels | What it tracks |
|---|---|---|---|
http_requests_total |
counter | service.name, application.id, api.name, http.request.method, http.route, http.response.status_code |
Total number of HTTP requests received |
http_request_duration_ms |
histogram | service.name, application.id, api.name, http.request.method, http.route, http.response.status_code |
Distribution of request durations in milliseconds |
http_errors_total |
counter | service.name, application.id, api.name, http.request.method, http.route, http.response.status_code |
Total number of HTTP requests that returned an error (4xx/5xx) |
http_requests_in_flight |
upDownCounter | service.name |
Number of HTTP requests currently being processed |
To add a custom metric, add an entry to the metricsDefinitions object:
export const metrics = metricsDefinitions({
http_requests_total: 'counter',
http_request_duration_ms: 'histogram',
http_errors_total: 'counter',
http_requests_in_flight: 'upDownCounter',
// Custom: count successful deployments.
deployments_completed: 'counter'
});Use counters for totals and event counts, histograms for distributions such as latency or payload size, gauges for directly observed current values, and up-down counters for values that change through increments and decrements such as in-flight requests.
| Guide | Description |
|---|---|
| Getting Started | Install the CLI and get your environment ready |
| Creating an Application | Initialize your first ForkLaunch application |
| Adding Projects | Add services, workers, libraries, and routers |
| Changing Projects | Modify existing project configuration |
| Deleting Projects | Remove services and clean up artifacts |
| Local Development | Run your full stack locally with docker-compose |
| Preconfigured Services | Use ready-made service blueprints |
| Customization | Adapt generated code to your conventions |
| Guide | Description |
|---|---|
| Contract-First Development | Design APIs from schema outward |
| Dependency Management | Manage cross-service dependencies safely |
| AsyncAPI Generation | Generate AsyncAPI specs for event-driven services |
| Pulumi Export | Export infrastructure as standard Pulumi TypeScript |
| Cache | Use TTL-based caching with Redis |
| Object Store | Store and stream large files with S3 |
| WebSockets | Build real-time APIs with type-safe WebSocket events |
| Testing | Unit and integration testing patterns |
| CLI Commands | Common CLI workflows and task sequences |
| Page | Description |
|---|---|
| Features | Complete overview of ForkLaunch capabilities |
| Project Basics | Understand applications, services, workers, and libraries |
| Artifacts | What ForkLaunch generates and why |
| Architecture | System design and internal structure |
| Reference | Description |
|---|---|
| CLI Reference | All CLI commands and options |
| Framework Reference | HTTP, validation, telemetry, authorization, and more |
| Contributing | Code of Conduct |
| Security |
Issues, discussions, and contributions are welcome.
ForkLaunch is designed to give you the flexibility of Express with the structure and productivity of a framework — without forcing a rewrite and without hiding the underlying infrastructure.
Let's build something real.