Open-source software factory

Run a production backend
without a platform team.

Sol turns your backend code into a production system — builds, infrastructure, deployment, observability, and operations included. Run it locally on the same stack as production, then deploy the same contract to Kubernetes in your own cloud.

Get started → Technical walkthrough

Pre-alpha · v0.1.0-alpha · not production-stableRoadmap ↗

⌘

Open source

Apache-2.0. Your Kubernetes cluster, your cloud account, your data.

✦

OCaml or TypeScript

Two first-class application languages behind one contract.

⚡

Evidence over magic

Qualification runs published from real AWS and GCP.

TerminalDeployStatusLogsRollback
$ sol local infra up
$ sol new workspace myapp
$ cd myapp && sol up

✓ k3d cluster: redpanda · postgres · loki · grafana
✓ charge_svc deployed · worker consuming events
✓ curl localhost:8080/health → ok

Local → production

“It worked locally”
should mean something.

Sol runs the same stack locally that you ship to production — same Helm charts, same service DNS, same security model. The only difference is scale. One application contract moves from your machine to your cloud.

01 sol local run Fast inner loop Native processes · one dune build · no image rebuild
02 sol up Production-shaped Real containers · real manifests · a real cluster
03 sol deploy prod/aws/us-east-1 Your real cloud AWS · GCP · or any Kubernetes

Same application contract · one deployment plan

How it works

Infrastructure is
a build artifact.

Sol reads your workspace and compiles it. Deployment, wiring, and observability are derived from the code — not hand-authored per environment, and not able to drift between local and production.

You write

  • Routes and handlers, with auth declared per route
  • Typed domain events
  • SQL migrations
  • A Dockerfile per unit
  • Service config and secrets in sol.toml
  • Domain boundaries — one team owns each domain

Sol derives

  • Kubernetes namespaces, Deployments, Services, CronJobs
  • Kafka topics, schema registration, consumer groups
  • The migration plan and tracking table
  • Service identity, metric and log labels, trace ownership
  • Image names and release identity
  • Observability wiring

Workspace convention — app/<domain>/<name>_{svc,worker,fn}/ with a Dockerfile

The application model

You bring the code.
Sol runs the system.

Three primitives cover backend work. Sol discovers them, verifies the runtime contract, builds an immutable artifact, and operates it — locally or in your own cloud.

_svc

Service

Long-running HTTP APIs with per-route auth.

_worker

Worker

Kafka consumers with retry and dead-letter routing.

_fn

Function

Scheduled jobs that run once and exit.

Runtime contract

  • PORT — the port the container listens on
  • GET /healthz — liveness and readiness
  • GET /metrics — Prometheus exposition
  • SIGTERM — drain and shut down cleanly

Application contract

  • Auth declared explicitly on every route
  • Typed, schema-registry-backed events between domains
  • PostgreSQL with typed access and migrations
  • Events are the only cross-domain contract — no shared code

Own your cloud

Runs on Kubernetes.
In your account.

Sol targets plain Kubernetes, not a proprietary runtime. Deploy straight to your cluster or emit manifests for GitOps — your cloud account, your registry, your data.

TargetsAWSorGoogle Cloudorany KubernetesAWS and GCP provisioning are experimental; any conformant cluster works.
⬡

Cloud-agnostic

One application model compiles to Kubernetes, wherever it runs.

◇

Direct or GitOps

Apply to your cluster, or emit manifests for Argo CD to reconcile.

♢

Escape hatches

Per-service overrides in sol.toml; generated Terraform and manifests are yours to take.

⌘

No lock-in

Open-source substrate — Kubernetes, Strimzi, Argo CD, Prometheus, Loki, Grafana, Terraform.

⌁Your App
◉Sol Factory
⬡Kubernetes
⌁Your Cloud Account

From code
to production.↖

Observability & operations

Wired in from the first message.
Operated with evidence.

Logs, metrics, and traces are part of the runtime contract, not a stack you assemble. The same CLI then tells you what is running, what changed, and how to put it back.

Built in, not bolted on

  • Structured logs shipped to Loki
  • Prometheus metrics exposed per primitive
  • W3C trace context across services and Kafka
  • Grafana dashboards over one workspace, not per service

Operated as one workflow

  • sol status — rollout state and Kubernetes diagnosis
  • sol releases and sol rollback — inspect and reverse
  • .sol/runs/ — deploy logs that outlive the terminal
  • Canary and blue-green rollout from sol.toml

Proof

Show the work.
Publish the evidence.

Sol is pre-alpha, and we would rather show the receipts than round up. The qualification runs, the end-to-end dogfood, and the current limits are all in the repository.

Qualification

Run against real cloud

Dated, reproducible qualification runs against real AWS and GCP — the same single-region path we intend to support.

Read the run records ↗
Dogfood

End-to-end, every release

New workspace to local cluster to deploy, observe, and roll back — exercised as the release path, not a demo.

Follow the tutorial ↗
Status

Honest about the edges

Single-region Kubernetes today. Multi-region, hosted, and cloud provisioning are experimental or not yet built.

See the roadmap ↗

Start with one service

Make production
boring again.

Start on k3d locally. Ship to your own Kubernetes cluster when you're ready.

Star on GitHub →Read the tutorial