Skip to content
Nebula FDE is the IDIYA pipeline, packaged for field engagements. See the engagement shape

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.

Discover. Specify. Build. Hand off.

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.

  1. 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

  2. 02G1 gate

    Rationalize

    Every fact gets provenance and a confidence; conflicts between sources go to the customer, never auto-resolved.

    signs: customer sponsor

  3. 03G2 gate

    Model the ontology

    Entities, relationships, state machines. The customer's domain owner confirms the diagram.

    signs: customer domain owner

  4. 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

  5. 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

  6. 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.

spec.json→HTML→forms→DB→plugin

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.

BUILDpassed
v1.0by D. Osei · Head of Procurement+ T. Brandt · Security
G0G1G2BUILDCONTRACT

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.

CR-001v1.0 → v1.1 Draft

opened by: K. Lindqvist · Third-Party Risk, Meridian Bank · impact: 2 forms, 1 table, 1 tool

migrationrollbackcontract script

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

portfolio · R. Mehta · 3 engagementsRoadmap
EngagementStageNext gateOpen CRs
Meridian Bank · Vendor Onboardingreleased v1.0BUILD v1.11
Halvorsen Energy · Equipment Inspectionspec interviewG2 ontology—
Lakeshore Regional Authority · Grant AdministrationrationalizeG1 inputs—

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
SOC 2Nebula runtime
HIPAAControls by design
Secret-pattern checkEvery release, blocks the tag

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.

Book a working session