Agreed in Writing. Then Built.
We map how the work actually runs, agree in writing what is being built and what is not, then build it in phases that each end with software you can use. You review working software early, accept it against the scope, and we keep running it after rollout.
01
Discovery & Scope
Map the work, agree what is built
02
Build & Review
Working software at each phase
03
Rollout & Operate
Into use, then we keep it running
Discovery to Operating, in Six Stages.
Three phases of work covering six named stages. Each phase ends in working software and a decision, so you are never asked to commit to the whole thing on the strength of a document.
Phase 01
Discovery & Scope
We map how the work runs, then write down what we are building.
Before anything is built we trace the real flow with the people who live it — the manual steps, the double entry, the approvals that happen verbally, the handoffs that go quiet. That becomes a written scope: what is being built, what is explicitly not, what it depends on from your side, and what it costs. Nothing starts until that document is agreed.
What this means: If the honest answer is that custom software is not the right call, that is the answer you get.
Discovery
We follow a job end to end and document every handoff and system it touches.
Scope Agreement
In writing: what is in, what is out, what we need from you, and the price.
Sequencing
Which phase comes first, chosen by what it costs you today — not by what is easiest.
Phase 02
Build & Review
You see working software at each phase, not at the end.
Builds are phased, and each phase ends with software you can actually use rather than a status report. You review it against the scope while there is still time for that review to change something. Acceptance is a specific step: we walk the agreed scope item by item and you say whether it is met.
What this means: Reviewing working software early is what stops a build drifting away from the operation.
Working-Software Review
Each phase ends in something you can open and use, and give feedback on.
Change Handling
Scope changes get priced and agreed in writing before they are built.
Acceptance
Checked against the written scope, item by item, and signed off by you.
Phase 03
Rollout & Operate
Into the hands of the people who use it — then we keep it running.
Rollout is planned with you: who moves first, what data comes across, what training the team needs, and what happens to the old way of working. Once it is live, the operating arrangement says plainly who is responsible for what — monitoring, fixes, changes and support — so nothing important is left to assumption.
What this means: We operate what we ship. You are not handed a repository and wished luck.
Rollout
Staged by team or site, with the data migration and training agreed beforehand.
Operating Responsibilities
Written down: what we monitor, what we fix, what response you can expect.
Ongoing Changes
The system keeps changing as the business does — scoped the same way each time.
Decide Again at Every Phase.
A build is broken into phases that each end in working software. That means you judge the work from something you can use, and the decision to continue is made with more information each time — rather than once, at the start, on a specification.
What We Need From You.
A build fails from the client side going quiet far more often than it fails from the code. Four things make the difference, and it is fairer to say them before you start than to discover them at week six.
One decision-maker
Someone who can settle a question the same week it is asked. Builds stall hardest when the answer to “which way should this work?” needs three people to agree and none of them own it.
Someone who knows the process
Not a manager's description of how the work runs — the person who actually does it. The gap between those two accounts is where most of the expensive surprises live.
Access, arranged early
Accounts, data exports and the systems we are integrating with. This is routinely the longest pole in the tent, because it depends on a third party's support queue rather than on us.
Feedback on working software
Each phase ends with something to use. A review that comes three weeks late costs more than it saves, because the next phase is already built on the assumption you did not correct.
How These Go Wrong — And What We Do About It.
Every one of these is a real failure mode in custom software. We would rather name them and show the counter-measure than let you meet them for the first time mid-build.
The scope grows quietly
Not through big requests — through small ones that each sound free. That is why scope is written down and why changes get priced and agreed before they are built, rather than absorbed until the timeline silently slips.
Written scope, changes priced in writing.
Nobody uses it
The most expensive failure in this category is not a bug. It is working software that the team quietly routes around because it was designed against how the work was described rather than how it is done.
Built with the people doing the work; rollout is a planned phase, not a login.
The data coming in is bad
A system is only as good as what it is fed. Migrating years of inconsistent records, duplicate customers and half-filled fields is real work, and pretending otherwise is how a launch turns into a cleanup project.
Data migration scoped explicitly, not assumed.
An integration breaks later
Accounting and field platforms change their APIs on their own schedule. This is normal, and it is why handoffs are built to surface a failure the day it happens rather than to fail quietly until month end.
Failure visibility built in; who fixes it is written into the operating arrangement.
Four Principles That Make This Safe to Try.
Trying something new on a live operation is a risk, so AltaPro AI AI works to four principles that keep it contained. We measure against real jobs rather than a benchmark or a demo. Products are co-built with the crews who live the work, not guessed at from a boardroom. We build it, run it, and stay accountable for how it behaves in production — partners never inherit a fragile prototype. And what proves out gets productized to one standard.
Scope Before Build
What is being built — and what is not — is written down and agreed before work starts. Most project failures are scope failures wearing a technical costume.
Working Software, Early
Each phase ends with something you can use. Progress you can open beats progress described in a status meeting.
You Own It
The software is built for your business and the data in it is yours, exportable on request. No per-seat meter on a system you paid to have built.
We Stay on the Hook
We operate what we ship and stay accountable for how it behaves in production, with those responsibilities written into the agreement rather than implied.
Hire, Rent, or Own?
Every growing business prices this eventually: another admin hire, another stack of subscriptions, or software built once around how the operation already runs. Here is the honest side-by-side.
Headcount
Hire an Ops Admin
Upfront Cost
Recruiting, onboarding, and weeks of training before the work flows.
Ongoing Cost
≈ $55,000/yr at Alberta's median admin wage — before payroll costs, benefits and vacation.¹
Availability
40 hours a week, minus sick days, vacation and turnover.
Who Owns the Data & Process
The process lives in one person's head — and leaves when they do.
When You Grow
More volume means another hire; the cost scales with headcount.
Year-3 Position
Three years of salary spent, and the next hire starts the training over.
Subscriptions
Rent SaaS Tools
Upfront Cost
Low — a credit card and a signup form.
Ongoing Cost
Typically $500–$1,500+/mo across the usual stack of seats and tools — per user, forever, repriced at renewal.²
Availability
24/7 uptime — but only for what the tool already does, the way it decides to do it.
Who Owns the Data & Process
Your data sits in their platform, under their terms, export limits and roadmap.
When You Grow
More seats, higher tiers, and more tools glued together by hand.
Year-3 Position
Three years of subscriptions paid, nothing owned, and the rent still due next month.
The AltaPro AI model
Build Software You Own
Upfront Cost
A scoped quote from the 30-minute call — cost and timeline agreed in writing before work starts.
Ongoing Cost
An operate-and-support arrangement set out in the scope agreement — not a per-seat meter.
Availability
24/7, built around your exact workflow — quotes, jobs, invoices, follow-up.
Who Owns the Data & Process
You. Your data, your process, your software — and we keep it running.
When You Grow
The same system absorbs the volume — software doesn't get busier.
Year-3 Position
A working asset your business owns outright — the build was paid for once.
¹ Median wage for administrative assistants in Alberta: $26.43/hr, about $55,000/yr full-time — Government of Canada Job Bank, 2023–24 wage data. ² SaaS figure is a typical multi-tool stack for a small team — illustrative, not a quote.
Find Out Where the Work Is Leaking.
The first step costs you a conversation and a look at how the work really runs. You leave with a scoped plan either way — including an honest read on whether we are the right firm for it.