Skip the Boilerplate. Build on the Same Production Foundation as Every Launch Rail Service.
A ready-to-clone Go microservice template that gives you ConnectRPC, OpenTelemetry, structured logging, PostgreSQL migrations, multi-tenancy wiring, and Docker setup — identical to the foundation every other service in the Launch Rail ecosystem is built on. Your domain logic, our proven infrastructure.
The Problem: Every New Service Starts from Zero
Your team ships a new domain service and spends the first two weeks wiring up logging, tracing, auth middleware, database migrations, and Docker. Then the next team does the exact same thing — differently. Six months later you have six services with six inconsistent infrastructure layers that are impossible to debug uniformly.
The Solution: One Foundation, Every Service
The Launch Rail Starter Kit is a production-grade Go microservice template that is structurally identical to every service in the ecosystem. Clone it once, drop in your proto definitions and domain logic, and your service is immediately instrumented, authenticated, and deployable — consistent with everything else your team already runs.
Everything Included. Nothing to Invent.
Every infrastructure concern that took months to get right across the Launch Rail ecosystem is pre-wired and ready to go.
ConnectRPC Transport
Simultaneous gRPC and REST/JSON from a single proto definition. Your service speaks both protocols on day one.
OpenTelemetry Tracing
OTLP-instrumented HTTP and database connections. Every request carries a trace from the wire to the query and back.
Structured slog Logging
JSON-formatted structured logging with request correlation IDs, tenant context, and caller information wired in by default.
PostgreSQL + Migrations
sqlc-generated type-safe query layer with goose migrations. Schema versioning, test fixtures, and a local docker-compose included.
Multi-Tenancy Wiring
Tenant context extraction from request headers is baked into every middleware layer — the same pattern used across the entire ecosystem.
HMAC Caller Auth
The same signed-envelope authentication pattern used by every Launch Rail service. Drop in your caller config and it just works.
Docker & Compose
Multi-stage Dockerfile optimised for minimal final image size, plus a compose file that boots Postgres and your service together.
Standard Makefile Targets
make dev-setup, make run, make test, make proto — the exact same ergonomics as every other service in the ecosystem.
Built for High Throughput
A clean, stateless architecture that scales horizontally. Decoupled inputs and outputs ensure zero-downtime operations.
REST / gRPC
ConnectRPC Gateway
MCP Server
AI Agent Interface
Service Logic
Domain Engine
PostgreSQL
ACID Compliant Storage
NATS / CloudEvents
Async Broadcasting
Identical Structure to Every Other Service
The Starter Kit isn't just a template — it's the exact same directory layout, the exact same middleware chain, and the exact same configuration pattern as Identity, Authz, Notifications, Audit Log, and every other service in the ecosystem.
- Any engineer familiar with one Launch Rail service is immediately productive in your new service.
- Shared tooling like lr-ctl, observability dashboards, and CI templates work out of the box.
- Adding ecosystem integrations (Audit Log events, Authz checks) requires minimal wiring.
- Upgrades to shared infrastructure patterns propagate predictably across all services.
my-service/ ├── cmd/server/ # Entrypoint ├── internal/ │ ├── config/ # Env-based config │ ├── domain/ # Your business logic │ ├── repository/ # sqlc-generated queries │ ├── service/ # Service layer │ └── transport/ │ └── http/ # ConnectRPC handlers │ └── swagger/ # OpenAPI spec ├── proto/ # gRPC definitions ├── migrations/ # goose SQL migrations ├── docker-compose.yml # Local dev stack ├── Dockerfile # Multi-stage build └── Makefile # dev-setup, run, test
Implementation Examples
Developer-first by design. Access full-featured gRPC, REST, and MCP endpoints out of the box. Our services use ConnectRPC for lightweight, production-grade communication.
Manage your infrastructure from the Terminal.
One-command provisioning
Create users, tenants, and roles without touching the UI.
Secure Key Management
Easily rotate API keys and manage workspace secrets.
Environment Sync
Synchronize permissions across staging and production.
Build vs. Buy Launch Rail
Why spend 4 months building table structures and plumbing when you can start shipping features tomorrow?
Build it Yourself
The "Not Invented Here" approach
Diving into low-level plumbing means your engineers aren't building your core product features. You risk security vulnerabilities and maintenance debt.
Buy Launch Rail
The "Speed of Light" approach
Get the source code, deploy it in minutes, and focus on what makes your business unique. Zero technical debt, enterprise-ready from day one.
| Feature Comparison | Self-Built | Launch Rail |
|---|---|---|
| ConnectRPC (gRPC + REST) | ||
| OpenTelemetry OTLP Tracing | ||
| Structured slog Logging | ||
| sqlc + goose Migrations | ||
| Multi-Tenant Middleware | ||
| HMAC Caller Authentication | ||
| Ecosystem-Consistent Layout |
Why Buy the Starter Kit?
Getting infrastructure right the first time takes months of trial, error, and hard-won production learnings. The Starter Kit packages all of that into a single clone.
Every custom service your team builds inherits the exact same production-grade foundation — no divergence, no reinvention.
Day-One Productivity
New engineers contribute to any service immediately — the structure is always the same.
Zero Reinvention
No more bespoke logging, tracing, or auth wiring on every new service.
Ecosystem Ready
Integrating with Authz, Audit Log, or Notifications requires minimal glue code.