Forward-deploy the spec, not the engineer.
The delivery platform for forward-deployed engineers.
Nebula FDE turns a discovery session — a Lovable prototype, Figma frames, screenshots — into a production app and its backend agent, signed off by the customer gate by gate. The engineer owns the spec. The platform owns the build.
5customer-signed gates
0lines of hand-written UI
1 · 1 · 1spec · tag · handoff
G2 ontology · signed by the customer
7 entities · 2 state machines · 0 inferred nodes left
BUILD · legal + security
parity 5/5 · tag contract-lifecycle@v1.0
CR-001 · opened by the customer
auto-renewal notice window · impact: 2 forms · 1 table · 1 tool
Built for the people in the room
FDE leadruns several engagements, reviews gates, sees every open CR
Forward-deployed engineerowns the ontology and the spec; never hand-writes a screen
Customer security & ITsigns the gates, inherits a spec and a tag, not a codebase
Where FDE teams use it
Regulated enough to need gates. Never someone's personal data.
The engagements that fit best share a shape: a real state machine, approvers from more than one function, company or asset data rather than people's, and an obvious first change request.
Enterprise
Contract lifecycle & obligations
Legal, procurement and finance all touch it; nobody owns the tooling. Drafting → review → executed → active → renewal due. The agent raises obligations before they bite.
also: SOX control evidence collection
Public sector
Grant program administration
Model the program, not the citizen: funding rounds, awards, milestones, disbursements, compliance reports. Four signatures at BUILD, and the audit trail is the strongest argument in the room.
also: infrastructure asset maintenance
Startup
Partner onboarding & deal registration
One founding engineer is the FDE for every design partner. Ship the first version in weeks; when the partner changes their mind, V2 is a change request, not a rewrite.
also: customer implementation tracking
The problem
Forward-deployed engineering doesn't scale. The code is why.
Every deployment is a bespoke build by an expensive engineer, and the artifact that leaves with them is code nobody else can own. The economics look like consulting, not software.
01
Unit economics
Six to twelve weeks of senior time per customer, most of it re-solving the same CRUD-plus-workflow-plus-agent problem in a new domain.
02
Snowflakes
Hand-written React, an API the model invented, a Supabase someone set up on day two. Nothing transfers between customers, and version 2 is a rewrite.
03
The handoff cliff
When the engineer rotates off, the customer inherits code, not a model. Security review happens after the build, which is where pilots die.
How it works
One engagement shape. Every customer.
Purple dots are gates the customer signs. The engineer's hands-on work is steps 01–03; everything after is generated and checked.
-
01Discovery
Bring what the room produced
Lovable prototype, Figma frames, screenshots, the customer's own forms. Any one is enough to start.
owner: forward-deployed engineer
-
02G1 gate
Rationalize
Every fact gets provenance and a confidence; conflicts between sources go to the customer, never auto-resolved.
signs: customer sponsor
-
03G2 gate
Model the ontology
Entities, relationships, state machines. The customer's domain owner confirms the diagram.
signs: customer domain owner
-
04spec.json
Spec + preview
spec.json is the only source of truth; an HTML preview is published for the customer to click through.
owner: engineer · reviewed by customer
-
05BUILD gate
BUILD
One approval generates the database, Nebula forms, the backend plugin and registers the agent. Nothing persistent before it.
signs: customer sponsor + security
-
06tag → handoff
Parity, release, hand off
spec ↔ HTML ↔ forms ↔ DB ↔ plugin verified, one commit, one tag. Post-release edits are change requests the customer can open.
owner: platform · customer keeps the repo
G0 (repo and platform access) precedes discovery. CONTRACT (approving a destructive DB script) is asked for separately, never inside a release.
5
Gates the customer signs. None pass on a timeout.
10
Form types every screen maps to. No bespoke UI.
37
Catalogued, pre-tested controls.
1
Tag per release. The handoff is a git ref.
Handoff
What the customer keeps when the engineer leaves.
“A spec, a tagged release and a change-request process — not a codebase and a Slack channel.”
the handoff test · every engagement
The spec
One editable artifact.
The spec, as JSON and as a readable document: entities, state machines, screens, roles, agent scope. IDs issued once, never renumbered. The customer's IT can read it without reading code.
Gate record Roadmap
Who signed what, and when.
Every gate records approver, time and version. Today it lives in the engagement state; a committed ledger that ships with each release is on the roadmap.
Parity report + release
Proof the build matches the spec.
Run before any release; a failure keeps the PR open. The tag is the handoff: one commit, spec, forms, DB scripts and plugin at the same version.
parity check · v1.0 html: ■ ok forms: ■ ok db: ■ ok plugin: ■ ok secrets: ■ none tag vendor-onboarding@v1.0 · merged
Change-request playbook
V2 is a CR, not a rewrite.
The customer opens a CR against the spec. Impact analysis walks the ID chain; the platform generates the migration, the rollback and the contract script, then asks for BUILD again.
opened by: K. Lindqvist · Third-Party Risk, Meridian Bank · impact: 2 forms, 1 table, 1 tool
Leverage
One engineer. Several engagements.
The interview, the ontology and the gates are the only parts that need a human in the room. A junior can run the spec interview; the senior engineer reviews the diagram and signs off with the customer. Forms, database, plugin and parity are generated.
Measure what changes: engagement weeks per engineer, and the share of V2 work the customer does without you.
01–03engineer in the room
04–06generated and checked
CRcustomer-opened, platform-built
Trust
Security review happens before the build, not after.
The customer's security lead signs BUILD with the preview, the agent summary and the DB change report in front of them. What gets built is metadata rendered by a tested runtime, not code the model wrote.
By construction · Nebula FDE
No hand-written UI. State machines enforced in the database. Role-gated data access. No secrets in any artifact. Secret-pattern check on every release.
Attested · Nebula runtime
Components and runtime designed to meet SOC 2 and HIPAA controls; attestation is published by the Nebula runtime team.
What the customer's security lead sees at BUILD
- The clickable HTML preview, every screen
- The agent summary: tools, skills, which roles can call what
- The DB change report, migration and rollback (on a CR)
- The impact list across the ID chain (on a CR)
- The pull request, in the customer's own GitHub
Where it runs
In the coding harness your engineers already use.
Nebula FDE is a plugin, not an IDE. Claude Code today; GitHub Copilot and Cursor adapters are on the roadmap. The pipeline, the gates and the artifacts are the same. Output lands in the customer's GitHub repo with a PR at the BUILD gate.
Claude Code
Native plugin format.
Installs as a native plugin; nothing else to wire up.
claude plugin install idiya-nebula
GitHub Copilot
Agent mode, same files.
Runs the same pipeline from the same repo.
Roadmap · adapter in progress
Cursor
Rules point at the plugin.
Same pipeline, same gates, same artifacts.
Roadmap · adapter in progress
Database scripts target SQL Server / Azure SQL today; PostgreSQL and MySQL are confirmed at spec time.
Compare
The classic engagement, and the Nebula one.
Same engineer, same customer, same problem. What changes is what gets produced, who signs it, and what is left behind.
| Axis | Nebula FDE engagement | Classic FDE engagement |
|---|---|---|
| Discovery output | A spec: ontology, state machines, screens, roles, agent scope — with provenance on every fact | Slides and a notebook; someone codes from them |
| The build | Generated from the spec: forms from ten catalogued types, database, backend agent, parity-checked | Hand-written front end and API, per customer |
| Customer sign-off | Five named gates with approver, time and version; nothing persistent before BUILD | Demos and a go/no-go email |
| Security review | At BUILD, with the preview, the agent summary and the DB change report in hand; the front end is never hand-written | After the build, on the code — where pilots stall |
| Version 2 | A change request the customer opens; impact analysis, migration, rollback and contract script generated | A rewrite, usually by whoever inherited the code |
| Handoff artifact | spec.json, a tagged release in the customer's GitHub, the parity report, the CR playbook | A codebase and a Slack channel |
| Who can run it | A junior runs the interview; the senior engineer owns the diagram and the gates | One senior engineer end to end |
| Where you build | Claude Code today; GitHub Copilot and Cursor on the roadmap | Whatever the engineer brought |
| Where it deploys | The customer's cloud: two runtime containers, handed to the Nebula deploy plugin at the release tag | Vendor-hosted pilot, migrated later — or never |
The classic column describes the common shape of forward-deployed engagements, not any one team.
Questions FDE leads ask
FDE work is bespoke by definition. How can a generator handle it?
The bespoke part is the ontology and the workflow rules, and those stay human: the interview, the diagram, the gates. Nebula generates only what is mechanical — forms from ten catalogued types, the database from the entities and state machines, the agent from the same spec. Where a screen does not fit the ten types, the spec says so; that is the customization budget, now visible instead of hidden.
What does the engineer actually do all day?
Steps 01 to 03: gather the discovery inputs, resolve conflicts with the customer, model the ontology and confirm the diagram, then review the spec and the preview before BUILD. A junior can run the interview; the senior engineer owns the diagram and signs with the customer.
Who approves the gates — us or the customer?
The customer. Approver name and role are recorded on every gate: the sponsor at G1 and BUILD, the domain owner at G2, security alongside the sponsor at BUILD. Nothing passes silently, on a timeout, or by self-approval.
What happens when the engineer rotates off?
The customer keeps the repo: the spec (JSON and readable document), the tagged release, the parity report and the change-request process. A new change is a CR against the spec, with impact analysis, migration and rollback generated — not a rewrite by whoever inherits the code.
Where does Nebula FDE run?
It is a plugin, not an IDE. It runs in Claude Code today; GitHub Copilot and Cursor adapters are on the roadmap. Output lands in the customer's GitHub repository with a pull request at the BUILD gate.
Which databases are supported?
SQL Server and Azure SQL are the reference path; PostgreSQL and MySQL are confirmed at spec time. The data store is never assumed from the inputs — the interview asks, and the answer decides the data layer the forms and the agent bind to.
Where does the application deploy, and who does it?
Nebula FDE stops at the release tag and manifest. The Nebula deploy plugin takes them to the two Nebula runtime containers in the customer's own cloud, under their IAM. Nebula never hosts their data.
Is it SOC 2 and HIPAA compliant?
By construction, Nebula FDE guarantees no hand-written UI, state machines enforced in the database, role-gated data access and no secrets in any artifact, with a secret-pattern check on every release. SOC 2 and HIPAA attestation is the Nebula runtime's, published separately.
After the tag · Nebula deploy plugin
The customer's cloud. The customer's security. Two containers.
Nebula FDE stops at the release — one commit, one tag, a release manifest. The Nebula deploy plugin takes it from there to the two Nebula runtime containers in the customer's cloud: one for the front end and one for the agent harness, under the customer's IAM. Nebula never hosts their data.
Customer's GitHub
vendor-onboarding@v1.0
one commit · one tag · manifest
Nebula deploy plugin
reads the manifest + tag
customer cloud · customer variables
Customer's cloud · customer's IAM
Front-end runtime
Renders Nebula form JSON
Agent-harness runtime
Runs the ontology agent + MCP
Customer security and authentication. Nebula never hosts their data.
Running
App + agent
every gate recorded: approver · time · version
Nebula FDE · builds and releases
Spec, HTML preview, Nebula forms, database scripts, backend plugin, parity check, one commit and one tag. Stops at the release.
Nebula deploy plugin · deploys and runs
Picks up the tag and the release manifest: runtime containers, cloud, IAM, and the runtime's SOC 2 / HIPAA attestation. Starts at the release.
Forward-deploy the spec,
not the
engineer.
Bring one live engagement. We'll run the discovery inputs through the pipeline with you and show the customer-signed gates on your own repo.