The plan is on a whiteboard, and it was wrong by Tuesday.
Jobs, materials and delivery dates all live somewhere different. We build the thing that holds them together, including the parts that only live in someone's head.
What you stop doing.
Not features. The jobs that come off your week once the system is carrying them.
- Rebuilding the schedule every time a customer changes something
- Walking the floor to find out what stage a job is at
- Finding out you're short material the morning it was meant to be cut
- Working out what a job really cost weeks after it went out the door
- Telling customers you'll call them back about their delivery date
What it costs you now, and what it looks like after.
A plan that's wrong by Tuesday
An order moves and the whole board gets rewritten by hand. The version on the wall and the version in someone's head drift apart.
A plan that updates itself
An order changes and the schedule reflows. Everyone sees the same board, including the floor.
Short of material on the morning
Sheets and hardware look fine on paper until someone goes to pull them. Then it's a scramble, a courier, and a job that slips a week.
Material checked before anything is cut
Requirements against what's actually in the store, with enough notice to do something about a gap.
Nobody can say what stage a job is at
Someone asks where a job is up to and the only way to answer is to walk out and look, or ring whoever touched it last.
Every part of the job has a state
Quoted, drawn, cut, assembled, finished, out for delivery. Every part of every job sits in the stage it is actually in, on a screen anyone can read.
No answer on delivery dates
Customers ask when it's shipping and the honest answer takes three phone calls.
Dates you can give with a straight face
Capacity and commitments in one place, so the answer to 'when's it shipping' takes five seconds.
Here's one we built.
Twenty-three orders, each sitting in the stage it is actually in. Two are flagged: one running behind, one waiting on material that lands Monday. Nobody walks the floor to answer "when will it be ready?".

Pick a time. In 72 hours you'll be clicking on it.
Half an hour on a video call is all it takes to find out whether any of this is worth building. There's nothing to prepare and nothing to sign.
- 01
You walk us through a normal week
How orders, jobs or stock actually move. No prep, no documents — just show us the screens you use.
- 02
We work out what's costing you most
Out loud, on the call. You'll hear what software can fix and what it can't, whether you hire us or not.
- 03
Within 72 hours you get a prototype
Real screens of your system, running in your browser, built from that conversation. Not a slide deck and not a mock-up.
Signs it's time.
None of these are about how big you are. They're about whether the admin is growing faster than the business underneath it.
- Changes agreed out loud on the floor, and nobody can say later what the order actually is
- A production plan that lives on a whiteboard or a spreadsheet
- Material shortages discovered on the day
- Jobs that are never quite the same twice, so nothing off the shelf ever fits
Your existing systems stay where they are.
Nothing gets ripped out. The system connects to what you already pay for and stops your team copying between them.
- Xero
- MYOB
- Bank feeds
- Barcode scanners
- Google Sheets
You see it working before you pay for it.
Most software projects ask you to approve a document and hope. This one shows you the thing first.
- 01Day 0
A 30-minute call
You walk us through how the work moves through your business today — the spreadsheets, the text messages, the thing only one person knows how to do. We record it, with your permission.
Nothing gets built on a guess.
- 02Within 72 hours
A prototype you can click
Real screens, built from that conversation, running in your browser. Not a slide deck and not a Figma file. You press it and tell us what's wrong.
You see your system working before you pay for it.
- 03Same week
A plan and a fixed price
Once we both agree on what it is, you get the build split into stages, each with a fixed price and a date. No open-ended hourly billing.
You know the price before you commit to anything.
- 04Week one
It goes live in pieces
Each stage ends with something your team actually uses, deployed to your own accounts. You're never waiting months to see progress.
Something new is running every week, on your accounts.
- 05The first month after
We stay on it
We watch it running and fix what comes up — the edge case nobody thought of, the report that needs one more column. You're not filing tickets into a void while your team works around a bug.
Included. You're not left alone with it the week after launch.
Three ways to get this built.
| Rewire Lab | Hiring in-house | A freelancer | |
|---|---|---|---|
| Something working before you pay | In 72 hours | You pay for months first | Deposit up front |
| Fixed price, agreed before the work | Yes — per stage | A salary, busy month or not | Hourly, open-ended |
| Time before it fits how you work | One call, then 72 hours | Hire first, then they learn it | Learns it on your clock |
| The month after launch | Included | Another month of salary | Billed hourly |
| You own the code and the accounts | From day one, documented | Only what they wrote down | Often not yours |
| Runs without you managing it | Yes | You manage a developer | You chase them |
| Cost to start | A 30-minute call | Salary + on-costs | Hourly from day one |
The ones that come up.
Is this an ERP?
No, and that's deliberate. An ERP asks you to change how you work to suit the software. This goes the other way: we build the few things that are costing you money and leave the rest alone.
Will the floor actually use it?
Only if it's faster than what they do now — that's the test every screen has to pass. So we design around the person doing the job rather than around a report, and where we can, we put it in front of someone on the floor before it goes live.
How long before something is in production?
A working prototype within 72 hours of the first call, and the first piece running on the floor inside the first week.
What happens after it goes live?
The first month is included. We watch it running and fix what comes up — the edge case nobody thought of, the report that needs one more column. After that we can stay on for support, or hand it over completely. It's your call, not a contract.
What happens if we stop working with you?
The code and the accounts are yours from day one, in your own repository and your own hosting. There's no lock-in and nothing to hand back.
Let's see if there's something worth building.
A free 30-minute call, no commitment. We go through how orders, jobs or stock move through your business and where the money leaks. You'll leave knowing what software can fix and what it can't — whether you hire us or not.
Book the call- 30 minutes, free, no obligation
- A working prototype within 72 hours
- A fixed price per stage, agreed before we start
- Nothing to pay until you've seen it