Now in early access

One source of truth for every build.

Stop parameter drift, stale work, and unqualified reuse. Prototype keeps specs, components, and approvals in one place so your team builds from the same truth.

Works with
FigmaSlackGmailGoogle DriveDiscordOutlineGitHub

Built for the build

Made for hardware teams, with one.

Prototype was built for and with UNSW Rocketry — a team running rockets, test rigs, and ground systems off the same configuration.

Propulsion lead, UNSW Rocketry
Airframe team, UNSW Rocketry
Recovery & structures, UNSW Rocketry
Project manager, UNSW Rocketry

Integrations

Seamless integration

Connect the tools your team already lives in — auth, data, docs, calendars, and chat — so every build stays in sync, not scattered across tabs.

Every device

Wherever the work happens.

Plan at your desk, review on the bench, approve from your phone. The same source of truth, on every screen.

Components tree — assemblies binding to specs
Screenshot · 9/19Mobile — home on your phone

The idea

From scattered to structured.

Specs, components, and documents start scattered across docs, spreadsheets, and people's heads. Prototype snaps them into one structure — scroll to watch the pieces click together.

02 · HOW IT WORKS

From spec to qualified build.

Each step feeds the next — specs define the rules, components bind to them, approvals gate change, and drift surfaces the moment it appears.

01

Define specs

Capture every parameter, limit, and constraint in versioned specifications — the rules every part must obey.

Stops parameter drift
02

Bind components

Link each component to the specs it must satisfy. Assemblies inherit from their children automatically.

Single source of truth
03

Review and approve

Route critical changes through configured signoff groups before they go live.

No unqualified changes
04

Catch drift early

When a parent spec changes, every bound component flags stale until someone re-checks it.

Prevents stale work

Capabilities

Everything a build needs to stay true.

A closer look at each capability — and where it lives in the app.

Versioned specifications

One source of truth for every parameter, constraint, and agreed value across the team.

app.prototype.dev/specs
Screenshot · 16/10Specification detail — versioned parameters

Component lifecycle

Track assemblies from planned to integrated. When a spec changes, bound components go stale until re-confirmed.

app.prototype.dev/components
Screenshot · 16/10Component detail — lifecycle & bindings

Approval workflows

Publishing specs and qualifying components requires explicit signoffs — no silent changes.

app.prototype.dev/approvals
Screenshot · 16/10Approval workflow — signoff before publish

Interfaces

Define mechanical, electrical, fluid, and software connections between parts — versioned like specs.

app.prototype.dev/components
Components tree — assemblies binding to specs

Milestones & tasks

Org-wide and per-project scheduling so nothing slips through the cracks before launch day.

app.prototype.dev/calendar
Screenshot · 16/10Milestone calendar — synced to your tools

Qualified library

Reuse proven configurations with envelope checks — no unqualified copy-paste from last year's build.

app.prototype.dev/library
Screenshot · 16/10Documents — files, links, and docs in one place

Compare

Built for engineering, not just writing.

Notion, Outline, and Confluence are excellent for writing. Prototype is built for engineering coordination — versioned parameters, component bindings, and drift detection that docs tools were never designed to enforce.

Capability
Prototype
Notion
Outline
Confluence

Versioned engineering specifications

Yes
Partial
No
Partial

Component–spec bindings with stale detection

Yes
No
No
No

Approval workflows on technical changes

Yes
Partial
No
Partial

Hardware / assembly lifecycle tracking

Yes
No
No
No

Qualified component library & reuse checks

Yes
No
No
No

Rich in-app documentation

Yes
Yes
Yes
Yes

Wiki / knowledge base

Prototype complements your wiki — it links Outline rather than replacing it.

Partial
Yes
Yes
Yes

Milestone calendar sync (iCal)

Yes
Partial
No
No

Outline & GitHub linking on parts

Yes
Partial
Partial
Partial

Threaded comments on technical objects

Yes
Yes
Yes
Yes

Team chat with @mentions

Yes
Partial
No
Partial

Manufacturing orders tied to components

Manufacturing workflow is in active development for early access.

Partial
No
No
No

Parameter drift prevention (core design goal)

Yes
No
No
No

About

Why we built Prototype.

We were a student rocketry team trying to build hard things fast — and losing more time to keeping track of the build than to the build itself. Prototype is the tool we wished we'd had.

Prototype started inside UNSW Rocketry. We were designing rockets, test rigs, and ground systems in parallel, across dozens of people who rotated in and out every semester. The engineering was hard, but the thing that actually slowed us down was simpler and more embarrassing: we couldn't agree on our own numbers.

A single chamber pressure or mass budget lived in a slide, two spreadsheets, a shared doc, and someone's head — and disagreed in all five. A component would get built to a spec that had quietly changed weeks earlier. A part that flew once got reused on a bigger motor without anyone checking it was still inside its limits. None of these were exotic failures; they were just the cost of coordinating real hardware in tools that were never built for it.

We tried the obvious fixes first — stricter spreadsheets, naming conventions, a wiki, more meetings. They all decayed the moment the team got busy, which was exactly when we needed them most. So we built the tool we wished existed: one place where a parameter is defined once and referenced everywhere, every component points at the specs it must satisfy, change ripples loudly instead of silently, and reuse is checked against the operating envelope before it ships.

Today Prototype is the canonical home for everything a hardware team is building — specs, components, approvals, and the documents that back them. It started as a fix for our own mess; it's grown into a coordination tool any team building physical things can rely on.

01

One truth, defined once

A parameter is set in one place and referenced everywhere. No copy-paste, no drift.

02

Change should ripple, loudly

When a spec changes, every component bound to it flags stale until someone re-checks it.

03

Nothing ships unqualified

Reuse is checked against the operating envelope. Approvals gate what goes live.

Pricing

Plans that scale with your team.

From a single team to a full program — and every tier is free while Prototype is in early access.

Small teams

Free

$0/ month

Up to 20 people

  • Up to 20 members
  • 20 GB upload storage
  • Versioned specifications
  • Component lifecycle & stale detection
Start free
Recommended

Growing teams

Pro

$15/ month

Up to 50 people

  • Up to 50 members
  • 50 GB upload storage
  • Everything in Free
  • Qualified component library
Start with Pro

Serious programs

Max

$40/ month

Up to 150 people

  • Up to 150 members
  • 100 GB upload storage
  • Everything in Pro
  • Advanced access controls
Go Max

Large organizations

Enterprise

Custom

Unlimited people

  • Unlimited members
  • Custom storage
  • Everything in Max
  • Priority support with SLAs
Talk to us

Indicative pricing while Prototype is in early access — plans aren't billable yet.

See full pricing →

FAQ

Questions, answered.

Answers to what hardware teams ask before they move their build onto Prototype.

Who is Prototype for?

Hardware teams that need one agreed source of truth — rockets, test rigs, ground systems, research. It was built for and with UNSW Rocketry, but it fits any team where the same parameter ends up in five places and drifts.

What does Prototype do that a wiki doesn't?

Notion, Outline, and Confluence are great for writing. Prototype enforces engineering coordination: versioned parameters, component-to-spec bindings, and stale detection that flags built parts when a parent spec changes. A wiki can't tell you a component went out of spec.

How big can my team be?

Team covers up to 10 people. Squad and Mission are unlimited members and projects. You can move up a plan as you grow without re-setting anything up.

Do we own our data? Can we export it?

Yes. Your specs, components, and documents are yours. Mission includes audit history and exports; export tooling is rolling out across plans during early access.

How is our data secured?

Data lives in Postgres with row-level security on every table, authentication through Clerk, and storage with scoped access. Permissions are checked per user, per scope — no policy means no access by default.

Is pricing final?

No — Prototype is in early access and the listed prices are indicative. Plans aren't billable yet. Get in touch and we'll set your team up.

Start building from one source of truth.

Bring your specs, components, and approvals into one place. Early access is open.

No credit card · early access

Contact

Talk to us.

Questions about fit, pricing, or getting your team set up? We read every message.

We usually reply within one business day.