The 30-Day Proof.
One problem. One team. Working software. Every engagement starts the same way: a fit call, then one real problem in your business, picked with your ops lead in the room, and solved with software your office and your field actually use, in production, in 30 days. If the proof earns it, we keep building the system with you, month to month. You own all of it from the first commit.
Four weeks, one linear path.
No parallel workstreams fighting each other. Every week has one job, and every week ends with something real.
Scope, architecture, and design.
We pick the one problem worth solving first and lock its scope, with your ops lead in the room. No endless discovery, just the decisions that matter.
- Kickoff and technical scoping with the people who will use it
- The workflow we are fixing, and what stays out of scope
- System architecture, stack and integrations
- Visual direction and component library
Core build.
Senior engineers ship the primary workflows end to end. Auth, data model, first real screens running on live data.
- Production auth, roles and permissions
- Database schema and API
- Primary screens wired to live data
- Daily builds you can open and click through
Integrations, polish, admin.
The connections that matter, and the admin you will actually run the business from.
- Accounting, payment gateways, financing partners, telephony, or whatever your core integrations are
- Admin for users, settings and data
- Edge cases, error states, and empty states
- Full QA pass, at the desk and in the field
Launch and handoff.
Production deploy, your data imported, and full ownership delivered to you on day 30.
- Production deploy with your existing data imported
- Crew app submitted to both stores, if there is one
- Repository, accounts and data transferred to you
- Launch-week support and handoff documentation
What ships. What doesn't.
The proof is deliberately scoped to one problem. Here is exactly what you get, and what is out of scope by design.
Included in the proof
- Working software for one real problem, in production
- Production backend: database, auth, roles and permissions
- Admin for users, settings and day-to-day ops
- Core integrations: accounting, payment gateways, financing partners, telephony, email, whichever apply
- A crew app for iOS and Android when the field needs one, submitted to both stores
- Your existing data imported
- Full source code and repo transfer on launch day
- Infrastructure transfer: you own the accounts
- Launch-week support and handoff documentation
Out of scope
- The whole platform in one go. One problem first; the rest follows.
- Ongoing marketing, growth or lead generation
- Rolling out to every seat on day 30. The proof ships to the team in the room; the wider rollout is the next phase.
- Hardware, firmware or embedded systems
- Blockchain, crypto wallets or on-chain logic
- “A quick rewrite” of an existing large codebase
What you do. What we do.
A 30-day proof only works if the lanes are crystal clear. You keep running the business. We stay in ship mode.
What you do
- Come to the fit call knowing which problem hurts most
- Put your ops lead, or whoever owns the process day to day, in the room for week one
- Review builds as they land and give tight, prioritized feedback
- Provide access to the accounts and data you want us to work with
- Be available for a short sync a few times a week
What we do
- Run scoping, design, engineering, QA and launch end to end
- Make architectural decisions and defend them in plain language
- Write production code on the main branch from week one
- Import your data, deploy to production, and hand over the keys
The questions owners and ops leads actually ask.
Straight answers. If yours isn't here, bring it to the call.
Can you really solve a real problem in 30 days?
Yes, when the scope is one problem. We pick it together in week one with your ops lead in the room, and we only take on a proof where 30 days is genuinely achievable. One tight problem fits: a commission run, a proposal-to-work-order chain, a partner transmittal. Replacing the whole platform in 30 days does not, and we say so on the fit call. The proof is the first piece, in production, and the rest follows month to month.
What if my crews won’t use it?
That is the risk we design against. Your ops lead sits in the scoping week, the field app is built for the conditions your technicians actually work in, and nothing ships to the field until the people who run it day to day have clicked through it. Software the field will not open is the most expensive kind, because the office ends up re-keying it.
Why not an off-the-shelf platform?
Often you should, and we will tell you. Off-the-shelf is the right tool for a standard workflow at a small size. The moment your process has a step it did not imagine, you are paying monthly to work around your own software. That is the business we build for.
How is this different from the big platforms?
The big platforms are built for a standard workflow and priced per seat, so the bill grows with every hire and the process still has to bend to the tool. An implementation you already paid for and a contract with years left make leaving harder than staying. We build the system that fits your process, you own it outright, and there is no per-seat fee, ever.
Who actually writes the code?
Senior engineers with years of shipping production software, on a team the founder leads start to finish. The person accountable on day one is accountable on day 30 and after it. No sales handoff to a team you never met, no ticket-mill, no layers between you and the people writing your code.
What happens after day 30?
You own the repository, the infrastructure and the data. Clients tend to keep us on monthly for the next phases. You can also take it in-house or hand it to another team. We are not trying to lock you in. The whole point is that you leave day 30 with a system you own.
Why not our platform’s professional services?
They can only configure what the platform already does. The step that does not fit stays outside it, in the spreadsheet, and you keep paying per seat for the part that does. We build the step, and the office around it, as a system you own.
Why not hire in-house?
Some clients do, after the proof. You own the repository, so an engineer you hire can take it over on day 31. Before that you would be hiring for architecture, integrations, a field app and a launch at once, and no single hire covers all four. We run the launch. You decide who runs the system after.
Ready to run on a system that fits?
If your office runs on a platform that fights your process, let's talk. One call. Thirty minutes. We'll tell you straight whether a 30-Day Proof is the right fit, or whether the platform you already have is.