What We Automate

Money in

Everything between finishing the work and the cash landing.

Quote follow-up

Today: Quotes go out and then sit. Whether anyone chases them depends on how busy the week was.
After: Every quote gets a follow-up sequence on a schedule, and anything gone quiet past a set age surfaces in one list.

Chasing a quote, without chasing it
A quote goes out and goes quiet. The sequence chases it on schedule, stops the moment someone replies, and requeues the ones that aren't a no.
What happens, in words
A quote is sent and then sits. Six days later nobody has chased it, because chasing it was nobody's job in particular.
The follow-up sequence runs on the schedule you set — day 2, then day 5 — and each send is logged against the quote.
When the customer replies, the chase stops immediately. Nobody receives a third nudge after saying no; that single rule is what separates a follow-up sequence from a nuisance.
A “not yet” isn't a dead end: the quote requeues itself for spring with the original attached, so it comes back on its own.
The quote that did convert was accepted off the second follow-up — one nobody wrote, sent on a day nobody chose.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Invoicing when the job closes

Today: Someone re-types job details into an invoice, days or weeks after the crew finished.
After: Completing the job drafts the invoice with the right line items, job reference, and customer already attached.

The invoice writes itself when the job closes
The crew marks the job done and the invoice is already built — right line items, job reference, customer attached — before anyone gets back to the office.
What happens, in words
A job finishes in the field, and the invoice for it is usually written days later from somebody's recollection of what was used.
Marking the job complete is the trigger. Parts and labour come off the job record as they were logged at the time — the backflow preventer at 11:40, three and a half hours from the job clock rather than an estimate.
The exception is the interesting part: a new part with no price on file is held rather than guessed at. The software asks one question instead of putting a made-up number into your books.
Everything else is drafted with the job reference and the customer already attached, ready to approve or to send on its own.
The gap between finishing work and billing for it goes from nine days to about an hour, which is the part that actually shows up in the bank.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Chasing unpaid invoices

Today: Nobody is sure what's overdue without opening the accounting system and reading down the list.
After: Overdue invoices escalate on their own — reminder, second reminder, then flagged to a human with the history attached.

Overdue invoices that chase themselves
Reminder, second reminder, then a human — with the whole history attached. Nobody has to open the accounting system and read down the list.
What happens, in words
Knowing what is overdue normally means opening the accounting system and reading down a list, which is why it happens in bursts rather than weekly.
The escalation runs on a schedule you set: a polite reminder at three days, a firmer one at ten, each logged against the invoice so there is a record of what was said.
The rule that matters is the one about replies. Northgate disputed the August billing, and the sequence stopped immediately — a third demand sent into an existing argument is worse than no chasing at all.
It hands the dispute to a person with every message and the payment history already attached, so whoever picks it up is not starting from scratch.
The invoices that were simply forgotten paid themselves off the reminders — $7,320 that week, chased by nobody.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Deposits and progress billing

Today: Deposits are tracked in someone's head or a spreadsheet, and the final invoice sometimes double-bills or misses the credit.
After: Deposits, milestones, and balances reconcile against the job automatically, so the closing invoice is right the first time.

Recurring and contract billing

Today: A monthly ritual of copying last month's invoices and hand-editing the ones that changed.
After: Recurring invoices generate themselves; only the genuine exceptions — skips, add-ons, price changes — need a person.

A month's invoices, and the three that need you
Ninety-six recurring contracts billed in one run — and the only thing left on your desk is the handful that genuinely need a decision.
What happens, in words
Ninety-six recurring contracts are due. Normally that's a full day of copying last month's invoices and changing the dates.
The run builds all of them in well under a minute.
Ninety-three were identical to last month, so they go out without asking you — there is nothing to check.
Three are held back: extra visits to bill or absorb, a contract that ended mid-month, and a price rise agreed by email but never written onto the contract.
That's the day's work reduced to three decisions instead of ninety-six copy-pastes — and the exceptions are surfaced rather than buried in the batch.
This is a concept mock-up, not a recording of shipped software. Recurring billing is something we build into your existing invoicing system during an engagement — the interface shown is illustrative.

Money out

Bills, approvals, and the receipts that never make it back to the office.

Supplier bill intake

Today: Bills arrive by email, post, and text photo, and land in three different places depending on who received them.
After: One inbox for bills, with vendor, amount, date, and job pulled off the document before anyone reviews it.

Approval routing

Today: Approvals happen by text or in the truck, and there's no record of who agreed to what.
After: Anything over a threshold routes to the right approver with the document attached, and the decision is logged.

Bills that find their own approver
A bill arrives, the rule picks who signs it off, and the decision is logged. No forwarding chains, no bill sitting in one inbox while someone is on holiday.
What happens, in words
Bills arrive by email and stop in whoever's inbox they landed in, which is why approving them takes eleven days and why one holiday can hold up a payment run.
Each bill is read, matched to a known supplier, and coded to the account that supplier's bills always go to — so the routing decision is made against real detail rather than a subject line.
The rule then picks the approver. Anything over $2,000 goes to the owner; below it, the office manager. That threshold is yours and it is visible, not buried in someone's habits.
A first bill from a supplier nobody has dealt with has no history to copy, so it routes to the owner and says exactly why it could not decide — rather than guessing or quietly parking it.
Every approval carries who decided and when, which is the part that cannot be reconstructed from a forwarded email chain six months later.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Receipts from the field

Today: Receipts live in glove boxes and phone camera rolls until month-end, and some never surface at all.
After: Crews photograph a receipt once, on the spot, and it arrives coded to the job with the purchase already matched.

A receipt, from the van to the books
A photo taken at the counter is read, matched to the job that crew was on, coded, and filed — before the van gets back.
What happens, in words
A receipt starts life as a photo on somebody's phone, in a van. Most surface at month end; some never do.
The photo is read on the spot — supplier, amount, tax — so nobody re-types it later from a crumpled original.
Then the part that actually saves the time: it works out which job the receipt belongs to, by matching where that crew was at the time, and codes it to the account that supplier always goes to.
When it can't read something — a fold across the total — it stops and asks, with the picture attached, rather than guessing a number into your books.
The rest are filed two minutes after the photo: attached to the job, and posted. Nobody empties a glovebox at month end.
This is a concept mock-up, not a recording of shipped software. Receipt capture is something we build into your existing tools during an engagement — the interface shown is illustrative.

Vendor records and W-9s

Today: You find out a W-9 is missing in January, when you need to issue 1099s.
After: New vendors can't be paid without the paperwork on file, and missing documents are chased before year-end.

Collecting a W-9, checked and verified
A contractor's W-9 arrives, gets read, gets checked against what they already told us, and gets verified — without anyone re-typing it.
What happens, in words
The contractor gets a link and uploads their W-9. No account to create, no email thread to keep alive.
The form is read automatically and eight fields — legal name, entity type, address, city, state, ZIP, TIN type and the last four digits of the TIN — are compared against the business profile already on record.
When something disagrees, it is flagged before anything is filed. In the recording the uploaded W-9 has the wrong city and ZIP, and the screen says so, with the fix spelled out rather than an error code.
Once the fields agree, one click submits it for TIN verification against the IRS-backed matching service.
The step closes itself out: on file, checked, dated, and logged. The full TIN stays in the encrypted vault — only a masked version is ever stored on the verification record.
The TIN match response is simulated in this recording. Everything else on screen — the upload, the extraction, the field comparison, and the records it writes — is the software running. Live engagements call the Tax1099 service.

Subcontractor payouts

Today: Sub invoices are checked against memory of what was agreed, and disputes get settled by whoever argues hardest.
After: Payouts reconcile against the scope and the completed work, with variances flagged before payment runs.

Paying subs without the spreadsheet
Approved work becomes a payment run, checked against what was actually done — and it refuses to pay a sub whose insurance lapsed last week.
What happens, in words
Subcontractor payments are usually a weekly spreadsheet, rebuilt by hand from job sheets, texts, and whatever anyone remembers agreeing.
The run builds itself from approved job records instead — hours, rates, and the jobs each sub was actually on, none of it re-keyed.
Seven of the nine subs need no thought at all and go through untouched.
The two it holds are the reason to have it. Kestrel Fencing's certificate of insurance expired on 22 August, and paying an uninsured sub moves their risk onto you. Whitmore billed eleven hours against a job the sheet says took six — most likely a second visit nobody logged, which is a question rather than an accusation.
Both would have gone out unnoticed in a spreadsheet, because nothing in a spreadsheet checks an expiry date against today.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Job and scheduling

Getting work booked, dispatched, and back to the office intact.

Job intake to schedule

Today: A call comes in, gets written on a pad, and someone re-keys it into the calendar later — if they remember.
After: Enquiries capture into one queue and become scheduled jobs without re-typing, whether they came by phone, form, or text.

From a phone call to a booked job
The request arrives however the customer sends it, and lands as a scheduled job with the address, the history, and the right crew already on it.
What happens, in words
Requests arrive however the customer feels like sending them — voicemail, text, the form on the website — and they all end up on a note somebody has to act on.
The voicemail is transcribed and matched against customers already on file, which brings the address and the June visit to the same zone along with it. That context is what normally requires someone to go looking.
With a customer and a job type identified, it schedules against the crew who already works that area on a Tuesday, rather than dropping it in the next free slot anywhere.
The seventh request is the honest one: no name, no address, just “the thing we talked about last week”. There is nothing to match, so it refuses to guess and hands it to a person with the recording attached.
Six of seven booked without a call back, and the two-day gap between asking and being scheduled closes to the same morning.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Dispatch and crew notifications

Today: Schedule changes are broadcast by group text and nobody's sure who saw them.
After: Crews get their day automatically, changes push through, and acknowledgement is visible.

The crew and the customer both already know
Schedule changes reach the van and the customer on their own — including the awkward one, when the crew is running two hours late.
What happens, in words
Eleven jobs and six phone calls asking where the crew is — the calls are the symptom, and they land on whoever is nearest the phone.
The first customer was told the window and the crew's name the night before, so there was nothing to ring about.
Then a backflow test overruns on a valve nobody expected. In the normal version of this day, the rest of the afternoon finds out by being stood up.
Instead the overrun itself is the trigger: the afternoon's customers are told at 12:04 that the crew is roughly two hours behind, with a real revised time rather than an apology. Cedar Court replies MOVE and the job rebooks without anyone making a call.
The crew's list in the van updates at the same moment, so the office and the van are looking at one version of the day rather than two.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Field-to-office handoff

Today: Photos, notes, and signatures come back by text to whoever the tech happens to message.
After: Job completion collects the photos, notes, and sign-off in one place, attached to the job record.

Job costing roll-up

Today: You find out whether a job made money weeks later, if anyone works it out at all.
After: Labour, materials, and subs roll up per job as they're incurred, so margin is visible while you can still act on it.

What the job actually cost, while you can still act on it
Labour, parts and subs roll up against the quote as they happen — so an overrun is a Tuesday problem, not a month-end discovery.
What happens, in words
Twenty-three jobs are running and what any of them actually cost is a question nobody can answer until month end — by which point the job is finished and the number is just history.
Labour, materials and subcontract costs roll up against the quote as they are logged, so the margin on a job is a live figure rather than a reconstruction.
Job 4462 was quoted at $8,400 and was sitting at 29% margin, which is fine.
Then a subcontractor was added on site and agreed verbally — $1,640 that was never in the quote — on top of a real labour overrun from ground conditions nobody could have priced. Margin drops from 29% to 4%.
The point is not the alert, it is the date on it: day six of a three-week job, while there is still a conversation to have with the customer. The same number found in November is only a lesson.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Change orders

Today: Extra work gets agreed verbally on site and invoiced hopefully.
After: Changes are captured and approved before the work happens, and flow straight to the invoice.

Client lifecycle

From first enquiry to the review — and the follow-up that never happens.

Lead capture and routing

Today: Enquiries arrive across a web form, a shared inbox, Facebook, and the office phone, and each is handled differently.
After: Every lead lands in one queue with its source attached, and gets a first response within a set time.

No lead waits until someone checks the inbox
Web form, missed call and inbox all land in one list, answered in minutes and routed to a person — with the one that isn't a lead marked as such.
What happens, in words
Enquiries arrive at nine at night, through a form, a missed call, or an inbox nobody owns — and get seen when someone next looks.
All three routes land in one list, and the customer gets a real acknowledgement within two minutes rather than an auto-reply that tells them nothing.
Scoring happens on facts you set: commercial rather than residential, inside the service area, and the kind of work you actually take. What survives reaches a person first thing with everything the enquirer said already attached.
The fifth was an SEO pitch. It is filed rather than deleted — you can see what was filtered and why, because software that quietly bins things on your behalf is software you stop trusting.
Five hours to first reply becomes two minutes, and the two enquiries that went unanswered last week become none.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

New client onboarding

Today: Each new client is set up from memory, so what they receive depends on who set them up.
After: A consistent sequence runs every time: welcome, paperwork, expectations, first appointment.

Reminders and no-show follow-up

Today: Reminders go out when someone has time, and no-shows are rebooked only if noticed.
After: Reminders send on a schedule; no-shows trigger a rebooking prompt and, where you charge one, the fee.

The no-show that rebooked itself
Reminders go out on a schedule, a reply moves the appointment, and the one nobody answers gets a person — before a crew drives out for nothing.
What happens, in words
Four no-shows in a week is four crews, four vans, and four hours that cannot be sold a second time.
Reminders go out on a schedule — two days before and on the morning — through the channel that particular customer actually replies on, with the arrival window and the crew's name rather than just a date.
A reply is treated as an instruction. Cedar Court answered MOVE and the appointment found the next slot that suited the route, not simply the next empty box in the calendar.
The appointment at Ridgeline Dr is the one worth watching: two reminders, no reply, access required, and forty minutes of driving each way. It is flagged to a person rather than cancelled automatically, because cancelling someone's booking on a guess is worse than the drive.
The reminders themselves are ordinary. Knowing which silence is expensive is the part that is hard to do by hand.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Review requests

Today: You ask for reviews when you remember, which is usually after a job that went unusually well.
After: Every completed job asks, at the right moment, through the channel that client actually uses.

Asking for the review at the right moment
Every finished job asks — through the channel that customer uses, at the moment they're happiest — and the unhappy one goes to you instead of to Google.
What happens, in words
Thirty-one jobs finished this month and four customers were asked for a review — all of them after a job that went unusually well, because that is when it occurs to anyone to ask.
Every completed job now asks, three hours after sign-off rather than instantly. The delay matters: the customer has had time to watch the work actually working.
The ask goes by text, one tap through to whichever platform the customer already uses, with no account to create.
The rule underneath it is the one worth having. Everyone is asked privately how the job went first, and only the happy ones are pointed at a public review. Ridgeline Dr rated it two out of five after a second visit for the same fault — so they got a phone call rather than a review link.
That ordering is the honest one, and it is also the one that produces better reviews: twenty-nine asked, seventeen posted, and the complaint reached you before it reached Google.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Reactivating lapsed clients

Today: Nobody notices a regular has stopped booking until they've been gone six months.
After: Clients who lapse past their normal interval surface automatically, with a prompt to reach out.

The regulars who quietly stopped booking
Customers who lapse past their own normal interval surface on their own — with the reason they left already attached, when there is one.
What happens, in words
A regular customer stopping is invisible, because nothing happens when somebody doesn't book. It surfaces six months later when someone happens to notice the name is missing.
The test is each customer against their own pattern rather than a blanket cut-off. Maple Ridge books every eight weeks and has not been seen in nineteen; Okafor books once every spring and missed one. Both are lapses, on completely different calendars, and a single six-month rule catches neither in time.
What surfaces is a short list with what each one usually books and what it was worth, so the outreach is a real conversation rather than a mail-merge.
Beacon Business Park is held back, and that is the part that matters. They logged a complaint in June that was never closed out — they did not drift away, they left. A cheerful “we miss you” to that customer is worse than saying nothing at all, so it goes to a person with the complaint attached.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

AI Automations

More advanced workflows where AI can listen, read, classify, draft, summarize, and hand off with guardrails.

AI receptionist

Today: Calls interrupt the day, voicemail gets checked late, and lead details are captured differently depending on who answers.
After: Routine calls are answered, qualified, summarized, and routed, with appointments booked or a human brought in when the call needs judgement.

AI operations assistant

Today: Someone watches inboxes, forms, and messages all day just to decide what needs a reply, a task, or a follow-up.
After: Incoming work is classified, summarized, drafted, and queued for review, so the team handles exceptions instead of sorting everything by hand.

AI recruiting screener

Today: Applicants pile up, screening calls get delayed, and basic fit questions are asked inconsistently.
After: Candidates complete a structured screening call, objective answers are summarized, and the hiring team reviews the results before making any decision.

AI document intake assistant

Today: Forms, PDFs, and email attachments have to be opened one by one to find missing or mismatched information.
After: Documents are read, key fields are extracted, missing items are flagged, and anything uncertain goes to a review queue.

AI follow-up assistant

Today: Quotes, onboarding tasks, unpaid invoices, and missing paperwork rely on someone remembering to follow up.
After: Follow-ups draft or send on approved rules, stop when the customer responds, and escalate when the situation needs a person.

Documents and compliance

Collecting paperwork, storing it somewhere findable, and knowing when it expires.

Collecting documents

Today: Chasing paperwork is a person's job: email, wait, email again, give up, escalate.
After: Requests go out with a link, chase themselves on a schedule, and show you exactly what's outstanding.

Signature routing

Today: Contracts get printed, signed, photographed, and emailed back — or not.
After: Documents route for electronic signature and file themselves once complete.

Expiry tracking

Today: Insurance certificates, licences, and certifications lapse and you find out from a customer.
After: Anything with an expiry date is tracked and chased before it lapses, not after.

Nothing expires quietly
Insurance, licences and certifications are watched against their own dates, chased before they lapse — and one that already has stops the work.
What happens, in words
Eighty-four documents are on file and their expiry dates effectively live in somebody's memory, which works until the week it doesn't.
Each document is watched against its own date and checked daily, rather than whenever someone thinks to open the spreadsheet.
Insurance is chased at sixty days, thirty and seven; a pesticide applicator licence and a backflow certification carry their own reminders, with the renewal form already attached so the chase includes the thing you need.
Kestrel Fencing's certificate of insurance expired ten days ago and they are on Thursday's schedule. The system does not simply warn about that — it takes them off Thursday and says why.
That difference is the whole point. A warning is something you can miss; an uninsured subcontractor on your site is your exposure, and the only useful response is to stop the work rather than mention it.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Filing and naming

Today: Files are named however the person saving them felt that day, and finding anything means asking someone.
After: A consistent naming and folder convention applied automatically, so documents are findable by anyone.

Reporting

Knowing where the business stands without building a spreadsheet first.

Recurring reports

Today: The same report is rebuilt by hand every week or month, from the same exports.
After: It builds and sends itself on schedule, to the people who need it.

Monday's numbers, already on Monday
The weekly pack builds and sends itself — and when a figure looks wrong, it says so on the report instead of letting you act on it.
What happens, in words
The weekly operations pack takes about three hours to assemble by hand from three systems, and it lands on Thursday because that is when somebody has time.
By Thursday, half of it describes a week everyone has stopped thinking about.
It now builds at seven on Monday morning and sends itself: invoiced, jobs completed, crew utilisation and outstanding — the same four numbers every week, so the comparison between weeks is real rather than dependent on who built it.
Crew utilisation came out at 78%, and two crews logged no hours on the Thursday. That is either a data gap or a genuinely empty day, and the report says so on its face rather than averaging the doubt away.
Flagging it on the report itself is deliberate. A number you cannot trust is more dangerous than a number you do not have, and a note buried in a log is a note nobody reads.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Owner dashboard

Today: Answering 'how are we doing' means opening four systems and doing arithmetic.
After: One view with the handful of numbers that actually drive decisions, current without anyone updating it.

The five numbers, without asking anyone
One board that answers what's coming in, what's going out and what's stuck — and admits when a number is stale rather than showing it anyway.
What happens, in words
Finding out where the business stands normally means asking three people and waiting two days, by which point the answer describes a business that has already moved on.
One board carries five numbers: quoted and not yet decided, work in progress, what is owed to you, what you owe, and what is in the bank. They are the questions an owner actually asks, rather than the ones that are easy to chart.
Every figure links through to the jobs and invoices behind it, so a number that looks wrong can be opened rather than argued about.
The bank balance is three days old because the feed last synced on Friday. It is shown greyed and dated rather than presented as this morning's cash.
That is the part worth insisting on: a dashboard that quietly presents a stale number as a live one is how people learn to stop believing dashboards, and a dashboard nobody believes is worse than no dashboard.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Month-end packet

Today: Close is a scramble to find missing receipts, chase approvals, and explain variances.
After: The packet assembles through the month, so close is a review rather than an excavation.

Job and customer profitability

Today: You know revenue by customer. Margin by customer is guesswork.
After: Costs attach to jobs and customers as they're incurred, so profitability is a report, not a project.

Which work is actually worth doing
Profit by job type and by customer, with overhead applied honestly — including the big customer who turns out to be the least profitable.
What happens, in words
Revenue by customer is easy and almost every system shows it. Profit by customer is the number that changes decisions, and almost nobody has it.
The same month's work, costed properly with overhead applied rather than quietly ignored, splits by job type: backflow testing at 61% margin because it is short and repeatable, irrigation repair at 38%, and new installs at 12% despite writing the largest invoices.
Beacon Business Park is the uncomfortable finding — twenty-four percent of revenue and four percent margin once callbacks and admin time are counted against it.
That is not an argument for dropping the customer. It is an argument for repricing the next contract, and the difference is that there is now a defensible number to do it with rather than a feeling.
The biggest invoices and the most profitable work are rarely the same jobs, and revenue reporting is structurally incapable of telling you which is which.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Exception alerts

Today: Problems are found by whoever happens to look — usually late.
After: The things that shouldn't happen raise a flag when they do: margin below threshold, invoice unsent, job unclosed.

People

Hiring, onboarding, and the admin that follows every employee.

Hiring pipeline

Today: Applications sit in an inbox and good candidates go cold before anyone replies.
After: Applicants are acknowledged immediately and move through visible stages with prompts at each one.

Applicants who get an answer
Applications land in one place, get screened against what the job needs, and everybody hears back — including the ones you're not hiring.
What happens, in words
Thirty-four applications arrived across Indeed, the website form and the office inbox. Nine people heard anything back, and the rest were still waiting after sixteen days.
Every application now lands in one list regardless of the route it came in by, which removes the main reason people fall through: nobody owns all three inboxes.
Sorting is against what the job actually requires. Seven applicants hold a current applicator licence, which is the one non-negotiable. Eleven have relevant experience without the licence, which is trainable and worth a conversation rather than an automatic no.
Sixteen get a straight answer within a day. Being told no quickly is a better experience than silence for a month, and it is the part that affects whether people apply to you again.
The boundary is deliberate: this screens, it does not decide. Nobody is ranked or scored or rejected by software, every applicant stays readable including the ones sorted out, and you can change your mind about any of them.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Employee onboarding

Today: Each new hire gets whatever the person onboarding them remembers to cover.
After: A checklist runs itself — paperwork, accounts, equipment, training — and shows what's outstanding.

Time and time off

Today: Hours arrive as texts and notes and get typed into payroll by hand.
After: Time captures at the source and flows to payroll, with exceptions flagged instead of everything re-keyed.

Time off that the schedule already knows about
Requests route to the right approver, land in the roster, and stop the booking that would have put a crew on a job while they're away.
What happens, in words
Time off is asked for by text and approved verbally in a van, which works fine right up until it needs to be known by anyone else.
The request goes through the app against a real balance — nine days remaining rather than a rough recollection — and routes to the person's actual supervisor rather than whoever answered the phone.
One approval updates the balance, notifies payroll, and changes the roster, so those five days simply stop being bookable for him.
Six weeks later someone schedules Beacon Business Park's quarterly test for the 16th of October and it is blocked, because Miguel is the only certified backflow tester and he is away that week.
The date on the catch is what matters. Six weeks out this is a scheduling question with several easy answers. On the day, it is a customer standing in an empty car park.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Certification tracking

Today: Licences and tickets expire quietly until someone can't legally do the job.
After: Every certification has an owner and an expiry, chased in advance.

Data hygiene

The unglamorous work that makes everything else trustworthy.

Duplicate records

Today: The same customer exists three times under slightly different names, so no report is quite right.
After: Duplicates are prevented at entry and the existing ones merged, once.

Keeping systems in step

Today: A customer's details are updated in one system and stale in the other two.
After: One system owns each field, and the others follow it automatically.

One customer, one version of the truth
A change in one system reaches the others — and when two disagree about the same field, it stops and asks rather than picking a winner.
What happens, in words
Customer data lives in four systems — the job software, accounting, the mailing list, and a spreadsheet nobody quite admits to — and a change usually reaches exactly one of them.
Dana Whitfield changed her phone number once. The job software knew; accounting and the mailing list carried on with the old one, which is how invoices go to dead numbers.
A change in one system now propagates to the others in the direction you decide is authoritative, which cleared fifty-eight of the sixty-one records that disagreed.
The remaining three are genuine conflicts, and this is where most sync tools quietly do damage. Accounting has Beacon at Suite 200, edited Tuesday; the job software has Suite 410, edited Wednesday. Both are real edits by real people.
Last-write-wins would silently keep Wednesday and destroy Tuesday's edit without telling anyone. This shows both versions with who changed each and when, and stops until a person decides.
This is a concept mock-up, not a recording of shipped software. We build this workflow inside your own tools during an engagement — it isn't a screen you log into. The interface shown is illustrative.

Consistent coding

Today: The same expense gets coded three different ways depending on who entered it.
After: Rules and defaults do the coding, with only genuine judgement calls left to a person.

Validation at entry

Today: Bad data is caught at month-end, long after the person who created it has forgotten the job.
After: Required fields and sanity checks catch it at the point of entry, when it's cheap to fix.

Clearing a cleanup backlog

Today: Years of accumulated mess that everyone works around because fixing it never gets prioritised.
After: A one-off structured cleanup, then rules that stop it rebuilding.

Not on the list?

The list isn’t the point.

These are the patterns we see most often, not a menu you order from. If your version of the problem isn’t here, it’s almost certainly a variation on something that is — and the audit is how we find out which.

Bigger than a variation? We do build custom systems, up to a full CRM or ERP — but only for companies we’ve already completed an engagement with. A platform that runs the whole business needs us to understand the whole business first, so it follows an audit, a cleanup, or a build. Never before one.

See how this looks in your industry →

Where to start

Don’t pick from this page.

Choosing the wrong thing first is how automation projects end up shelved. The audit ranks them by what each one is actually costing you.

The work that quietly eats a day a week.

Everything between finishing the work and the cash landing.

Quote follow-up

Chasing a quote, without chasing it

Invoicing when the job closes

The invoice writes itself when the job closes

Chasing unpaid invoices

Overdue invoices that chase themselves