Applications and services
Documented REST and Connect/gRPC contracts
Starter Kit · Design-partner pilot
Skip the Boilerplate. Build on a Shared Service Foundation.
A ready-to-clone Go service baseline with ConnectRPC, OpenTelemetry, structured logging, PostgreSQL migrations, multi-tenancy wiring, and Docker setup—aligned with the conventions used across the Launch Rail ecosystem. Your domain logic, one repeatable foundation.
REST APIgRPCMCP via Agent Gateway
The Problem: Every New Service Starts from Zero
A team ships a new domain service and rewires logging, tracing, auth middleware, database migrations, and Docker. The next team repeats the work differently, leaving inconsistent infrastructure layers that are difficult to review and operate uniformly.
The Solution: One Foundation, Every Service
The Launch Rail Starter Kit is a design-partner Go service baseline built around the same project, middleware, configuration, and observability conventions used by the ecosystem. Add your proto definitions and domain logic while keeping the surrounding service shape consistent and reviewable.
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.
Service architecture
Clear interfaces around focused domain logic.
Stateless service processes can scale horizontally, while durable writes, event delivery, and agent access keep explicit operational boundaries.
Agent Gateway
Tenant scope, allowlists, approvals, budgets, and audit
Domain service
Tenant-aware business rules, validation, authorization hooks, and observable request handling
PostgreSQL
Transactional, customer-controlled persistence
NATS and CloudEvents
Decoupled delivery for downstream workflows
The exact topology, replicas, recovery objectives, and provider configuration are documented for the customer deployment rather than hidden behind a generic availability promise.
Shared Structure Across the Ecosystem
The Starter Kit follows the directory, middleware, and configuration conventions used by Identity, Authz, Notifications, Audit Log, and the broader Launch Rail ecosystem.
- Engineers familiar with one Launch Rail service can recognize the same conventions in a new service.
- CLI inputs, observability conventions, and CI templates can follow the same project shape.
- Adding ecosystem integrations (Audit Log events, Authz checks) requires minimal wiring.
- Changes to shared infrastructure patterns can be reviewed consistently across services.
Project Structure
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. Available services expose documented REST and Connect/gRPC contracts. Agent access is routed through the governed Agent Gateway instead of exposing unrestricted service credentials.
Bash Code
Command Line Interface
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.
launchrail-ctl — zsh
$
Connected: Staging-US-East-1Latency: measure in target environment
Build versus integrate
Start from one product system, not a pile of infrastructure tasks.
Launch Rail packages recurring SaaS domain work into interoperable modules while your team keeps the source, deployment, and product-specific decisions.
Assemble it yourself
Coordinate separate domain, API, deployment, and operations workstreams.
Your team owns every decision, but also has to align schemas, authorization, event contracts, observability, upgrades, and customer-cloud deployment across independently built components.
Integrate Launch Rail
Adopt a consistent, source-owned ecosystem baseline.
Begin with compatible service boundaries, a shared tenant model, repeatable local tooling, customer-cloud artifacts, and one support path—then adapt the product logic your market actually differentiates on.
| Capability | Self-built baseline | 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?
Establishing consistent service conventions requires design, implementation, review, and ongoing maintenance. The Starter Kit pilot packages the Launch Rail baseline into one starting point.
Custom services can begin with the same conventions and compatibility expectations as the Launch Rail ecosystem.
Day-One Productivity
New engineers contribute to any service immediately — the structure is always the same.
Less reinvention
Reuse logging, tracing, and tenant-context patterns instead of defining each baseline independently.
Ecosystem Ready
Integrating with Authz, Audit Log, or Notifications requires minimal glue code.