Platform
What your software runs on
The factory builds your system. This is the platform it runs on once it is built. Every engagement is delivered on greenfield-ts, our production TypeScript platform, where event sourcing, typed contracts, observability, and authorization are part of the runtime instead of something each project reinvents. For regulated work, greenfield-wasm adds sandboxed execution and an immutable audit trail. The discipline the gates enforce during the build is the discipline the platform keeps in production.
Both are proprietary platforms we build and maintain. The deep technical documentation lives off this site; what follows is what they are, who they are for, and what you own.
greenfield-ts
The production TypeScript platform
A zero-infrastructure platform for microservices: developers write business logic, and the runtime handles the parts every production system needs and most teams rebuild from scratch.
Typed contracts
every command, query, and event is a compile-time type, so one service cannot send a message another service does not understand.
Event sourcing
state changes are recorded as an append-only history that can be replayed, so the audit trail exists by construction rather than as an afterthought.
Message bus
services talk over a bus instead of a tangle of direct calls, which is what lets them scale and fail independently.
Built-in traceability
a correlation ID is attached when a request enters and rides every message it spawns, so a single request can be followed across every service it touches without a line of tracing code. Traces export to OpenTelemetry, and fields marked sensitive are stripped from logs and traces by default.
Authorization
two layers, both part of the runtime: the gateway checks permissions before a message reaches your service, and a handler can require a business policy before its own logic runs.
Proven infrastructure
PostgreSQL, RabbitMQ, and Redis underneath: infrastructure operations teams already run, staff, and trust. The novelty lives in the architecture above them, and the dependencies you bet your uptime on stay familiar.
The payoff is uniformity. The infrastructure is the same across every service, so the audit trail is there by default and a new engineer reads one platform instead of one bespoke setup per project. It is at version 1.0, and it holds its own codebase to the same bar we apply to client work: the build fails below the coverage threshold the factory's gates enforce.
greenfield-wasm
The compliance-grade runtime
For work where you have to prove not just what the software does, but who did what and when. Built for teams under audit obligations: financial services, government, healthcare.
greenfield-wasm runs each handler in a WebAssembly sandbox with explicit resource limits and capability-scoped access. A handler can only call what its interface grants, so a read-only projection has no path to write at all; the boundary is enforced by the interface itself, so there is no runtime check to slip past.
Every external call, including every model prompt, is written to an immutable log stamped with the caller's identity by the host. The logging interface has no identity field, so a compromised handler has nothing to forge. An agent acts with the intersection of its own declared scope and the user's, the history can be replayed for review, and the whole thing runs on PostgreSQL alone, with no extra message broker to secure and audit.
Because regulated work eventually meets an auditor, the evidence is built to leave the building: a compliance pack is cryptographically signed, so a reviewer can verify it offline, without any access to our systems.
Both greenfield-ts and greenfield-wasm are production-grade. greenfield-wasm carries the heavier guarantees, sandboxing and an immutable audit trail, because the regulated work it is built for cannot tolerate less. As with everything we ship, we state plainly what is covered for your specific deployment before it touches anything you depend on.
Ownership
What you own, and what you license
The platform is ours; your software is yours. The application code we write for you, the specs, the behavior catalog, the architecture decision records, and the tests are yours to keep, read, and change; that is the whole point of shipping the record. The platform underneath, greenfield-ts and greenfield-wasm, is licensed proprietary technology. It is not open source today, though we are weighing an open-core model and will not claim a license we have not shipped.
For continuity, source-code escrow is available as an add-on on premium plans and is included with Enterprise. A third party holds the platform source and releases it to you under defined conditions, so you can recover and keep running the platform if we ever cannot support it.
The result is the opposite of a black box you cannot recover: you hold the code and the record of what it does, and a contractual path to the platform source underneath it.