Sprout
An agent-native cloud for deploying and sharing small, purpose-built applications.
The control plane and data model are built; the Go API and real deployment runtime are in progress. Walkthroughs of the prototype are available on request.
The problem
Small internal applications are increasingly easy to generate but still disproportionately difficult to deploy, operate, secure, and share with a handful of coworkers.
Coding agents can create a useful application quickly, but making that software safe to run and simple to share still demands deployment infrastructure, identity, configuration, logs, permissions, and operational knowledge.
The approach
Designed one progressive product path from application intent to workspace operations, backed it with an explicit frontend API boundary and PostgreSQL domain model, and began a deliberately small Go control service for infrastructure-facing work.
Starts where code generation ends: a calm control plane for turning application code into an isolated, observable, shareable workspace without exposing traditional cloud complexity.
Defining decision
Validate the complete product workflow through a typed control-plane prototype, then replace its mock adapter incrementally with one modular Go API while keeping Drizzle as the single schema and migration owner.
Modeling infrastructure states before the runtime exists makes the product testable early, but every simulated capability must stay clearly labeled until the real build, isolation, DNS, and log pipeline replaces it.
How it works
Step through the system. Each stage lists the safeguard that keeps it trustworthy.
App Intent
A developer or coding agent brings a small purpose-built application that needs a safe place to run.
Keeps Sprout focused on deployment and operation rather than becoming another general-purpose code generator.
Architecture notes
- The Next.js product surface uses TanStack Query and typed domain hooks so the current mock adapter can be replaced without coupling UI components to fixtures.
- PostgreSQL models tenants, applications, deployments, stage events, resources, access grants, environment metadata, and agent runs; Drizzle remains the only migration owner.
- The Go backend is being introduced as a modular monolith so deployment coordination can gain explicit cancellation, capacity, failure, and shutdown behavior without premature microservices.
Current implementation proof
Built and working
- Responsive Next.js control-plane prototype spanning apps, deployments, logs, environment, access, workspace activity, and agent journeys
- Twelve-table PostgreSQL model for workspaces, applications, deployments, resources, access grants, and agent run history
- Tested Go 1.27 backend executable that establishes the service boundary for the future deployment and agent API
Engineering signals
- Responsive control-plane prototype with typed server-state boundaries
- Local PostgreSQL 16 setup with one verified migration and twelve application tables
- Go service foundation verified with tests, vet, and native build
What’s next
Build the first versioned Go HTTP slice for health, workspace authorization, and application reads before moving into the smallest real repository-to-container deployment loop.