Overview
A product is finished when someone else can build it
A working prototype answers one question: can this be made to work at all? Product development answers a harder one: can this be built correctly, by other people, hundreds of times, on days when none of the original engineers are available.
That second question reshapes almost every decision. Component choice becomes a lifecycle decision. Board layout becomes a test-access decision. Firmware structure becomes a field-update decision. None of those are visible in a prototype that works on a bench.
We engineer for the second question from the beginning, because retrofitting it is almost always more expensive than designing for it.
Engineering principles
- Requirements written before architecture
- Evidence produced at every stage
- Buildability designed in, not bolted on
- Complete handover, no supplier lock-in
The programme
Eight stages, and the joins between them
Stages overlap in practice. What does not change is that each one produces evidence the next one depends on.
Discover
Requirements, constraints and technical risk are mapped before a single component is chosen.
Architect
Hardware, embedded and connectivity decisions are made together as one system architecture.
Design
Schematics, board design and software structure are developed against the agreed architecture.
Prototype
Physical boards are built and measured so assumptions are replaced with evidence.
Engineer
Firmware, drivers and hardware are refined until the product behaves as specified.
Validate
Functional, integration and reliability testing verify the design against its requirements.
Production
Documentation, test tooling and manufacturing data prepare the design for repeatable builds.
Evolve
Products are maintained, modernised and extended across their service life.
Handovers
The cost of handovers
Every boundary between suppliers is a place where an assumption can be lost. The hardware house assumes the firmware will manage the rail sequencing. The firmware house assumes the hardware guarantees it. Both delivered what they were asked for, and the product still browns out at cold start.
Keeping architecture, board, firmware and test inside one team removes those boundaries. It does not remove the problems — it just means they surface during bring-up, where they are cheap, instead of during validation, where they are not.
Scope
What each stage produces
Deliverables are agreed at scoping; this is the usual shape of them.
| Stage | Engineering | Evidence produced |
|---|---|---|
| Requirements | Functional, environmental, regulatory and cost constraints captured | Written requirement set and risk register |
| Architecture | Hardware, embedded and connectivity structure decided together | Architecture document and component strategy |
| Design | Schematics, multilayer layout, software structure | Schematics, layout, fabrication data, BOM |
| Prototype | Boards built, brought up and measured | Bring-up report and measured performance |
| Firmware | Drivers, control logic, communication, diagnostics | Source, build system, unit and integration tests |
| Validation | Functional, integration, environmental and reliability testing | Test reports against the requirement set |
| Production readiness | DFM, test strategy, documentation, supplier support | Build pack, test procedures, first article support |
| Handover | Transfer of design ownership | All design data, source and documentation |
Engagement
Ways teams work with us
Programmes are scoped around what you already have, not around a fixed package.
- Full programme
- Concept through to production readiness, one accountable team
- Stage entry
- Join an existing programme at design, prototype or pre-production
- Discipline support
- Add hardware, PCB, embedded or test capability to your team
- Design review
- Independent technical review against constraints, findings written up
- Modernisation
- Restore buildability of an existing product
- Production support
- DFM, build packs and supplier coordination only
Prototypes prove an idea. Products prove a process. The engineering that separates them is the part most programmes underestimate.
FAQ
Product development questions
What clients ask before committing to a full programme.
Yes. A full programme runs from requirements and architecture through design, prototyping, firmware, validation and production readiness, ending with a build pack a manufacturer can work from.
No. We are an engineering company. We prepare the design, documentation and test strategy for manufacture and support the manufacturer through first builds, but we do not operate production lines.
Yes. We regularly join at design, prototype or pre-production stage. The first step is a review of what exists and what evidence is already available.
You do. Schematics, layout and fabrication data, firmware source, test procedures and documentation are handed over as deliverables.
It depends on complexity, regulatory scope and how much evidence is required. Timelines are estimated at scoping against a defined deliverable list rather than quoted generically.
Next step
Describe the product you want built
Tell us what it has to do and what it has to survive. We will tell you what engineering the programme needs, stage by stage.