- November 15, 2025
- Posted by: Justin Prince
- Category: Applied Technology
4:02 pm.
“Payroll variance flagged. Possible underpayment across 112 employees.”
HR froze. Finance opened spreadsheets. Ops was already on a call they couldn’t leave. By 5:17 pm, the issue wasn’t the variance. It was the mess between our systems:
- data retyped from one system into another
- shadow spreadsheets
- three different “sources of truth”
- a dozen Slack threads trying to reconcile it all
We weren’t short on technology. We were short on structure.
That afternoon we made a decision: we wouldn’t “turn on AI”. We would earn it – one step at a time.
What follows is the year we climbed from “an app for everything” to what we now call Global AI: a smart layer over our business that can safely see what’s going on, suggest next steps, and (with permission) make updates across systems.
It’s not a shopping list of tools. It’s a sequence.
Step 1 – Admitting the real problem
In the post-mortem, the CFO asked one question:
“Where does the real payroll truth live?”
Silence. Everyone had a different answer.
That’s the first stage of most businesses today:
Lots of apps. Not much agreement.
We had great tools in HR, payroll, projects, safety, rostering, timesheets, CRM… but no shared rules for:
- which system is “the real one” for each thing
- how data should move between them
- who owns which parts
So we did something very un-flashy, but powerful:
- We wrote down our outcomes – not “go live”, but things like:
- “Stop re-typing data between systems”
- “Cut the end-to-end payroll cycle time”
- “Be able to see what’s happening in the systems, not guess”
- We chose our “official” systems.
A short list: which system is the real one for employees, for projects, for costs, etc. - We made one front door for people – one login to get into everything.
- We gave every system an owner.
Someone whose job it is to care about usage, data quality, and “does this still make sense?”
By the end of that quarter, if 4:02 pm had hit again, we still would’ve had a problem – but we wouldn’t be hunting through five random exports just to see what was going on.
Step 2 – Connecting things so people stop re-typing
Once we knew our “official” systems, the next ugly truth was obvious:
We didn’t have an AI problem.
We had a copy-and-paste problem.
People were downloading CSVs from one system, emailing them to someone else, and manually keying numbers into another. “Integrations” were a mix of brittle scripts and “oh yeah, we meant to fix that”.
We set a simple rule:
If data needs to move regularly, humans shouldn’t be the pipe.
So we:
- picked a small set of important connections (e.g. HR → payroll, field app → finance)
- replaced manual exports with digital connections (APIs)
- gave each connection an owner
- wrote down, in plain language:
- what moves
- how often
- what to do when it breaks
Nothing fancy. Just fewer surprises and fewer excuses.
By now, if 4:02 pm had hit, at least most of the data would already be in the right place. We’d still have questions – but the plumbing wouldn’t be the first suspect.
Step 3 – A core stack people actually use
(Not “buy a monster system and hope”)
Here’s the next pattern we hit – and I see it everywhere:
- “Serious companies” buy a huge all-in-one system.
- It’s expensive and complex.
- People stick with Excel and their old tools.
- Once a month someone shovels numbers into the big system so it looks “up to date”.
Sound familiar?
We chose a different path:
Unless you’re a big global with huge governance, don’t try to run your whole world on one mega-system.
Instead, we designed a core stack of systems that made sense for our size and shape:
- one for people
- one for projects and jobs
- one for finance
- a few specialist tools for operations
Each system had:
- a clear job
- a rule: “if it’s not in the system, it doesn’t exist”
- connections to the other core systems, so data flows instead of getting stuck in inboxes
We then went after shadow spreadsheets and workarounds. Not with blame, but with curiosity:
“If you felt you had to build your own tool in Excel, what was missing from the system?”
We fixed the gaps and retired the worst offenders.
By the end of this stage, we had:
- a core stack people actually used
- less “secret” Excel
- a much clearer picture of reality
Step 4 – A simple data hub and helpful AI sidekicks
Next problem: reporting.
Every system had its own dashboard. None of them agreed.
Leaders would ask basic questions like:
- “How many people do we really have on Project X?”
- “What’s our true margin when we factor in overtime?”
…and we’d go back into spreadsheet land for days.
So we did two things:
- We built a simple “data hub”.
Not a huge data science project. Just one place where key data (people, projects, costs, risks) is pulled together for reporting. - We agreed on shared definitions.
- What exactly counts as “headcount”?
- What is “overtime cost”?
- When we say “project margin”, what’s in and what’s out?
Once that was in place, we could safely plug in AI helpers:
- “Summarise the last 10 cases for this client.”
- “Draft a letter explaining this payroll correction in plain English.”
- “Show me which projects have risk signs similar to this one.”
The AI wasn’t guessing from the general internet. It was reading from our data hub and our policies.
And we put simple rules around it:
- things it can answer on its own
- things it must send to a human for approval
- logs of what it looked at and what it suggested
This is where a tool like Ask Frank slots in beautifully for HR and IR: it knows the Australian rules, reads your documents, and turns complexity into clear steps and draft words. It doesn’t replace judgement – it accelerates it.
Step 5 – “Global AI”: a calm, always-on business
The final step wasn’t a single project. It was a gradual shift.
We stopped thinking of “AI tools” and started thinking of an “AI layer” over the business:
- It can see across people, projects, costs and risks (within privacy and legal limits).
- It can notice patterns and nudge humans before they become 4:02 pm fires.
- It can, with clear permission, make small updates across systems and log what it did.
In practice, this looked like:
- leaders asking: “What are the three biggest payroll risk patterns this month?” and getting answers in minutes
- frontline teams using AI as a normal part of their day (like a smart colleague), not a special experiment
- roles and processes being adjusted so AI does the heavy lifting and people focus on judgement, relationships and improvement
And the next time 4:02 pm rolled around?
The system had already:
- noticed the pattern
- linked it to a recent configuration change
- paused risky runs
- drafted communications and tickets
- queued a safe fix for someone to approve
No war room. Just work.
Where are you on this ladder?
Use these questions to place yourself:
- Stage 1 – Tool for Everything
- Does every problem get a new app?
- Do leaders get different numbers depending on who they ask?
- Stage 2 – Patchwork Connections
- Are people still emailing CSV files around?
- Do “integrations” break quietly and no one notices until month-end?
- Stage 3 – Core Stack
- Do you own a big system that looks good in board packs but no one loves using?
- Is Excel the real system of record?
- Stage 4 – Data Hub + AI Helpers
- Do dashboards from different systems disagree?
- Are people using AI on the side, but it’s not plugged into real work?
- Stage 5 – Always-On AI (Global AI)
- Does AI feel like a slide, or like a colleague?
- When something goes wrong, does the system help you early, or just shout once it’s already bad?
Wherever you are, the next move is usually simple, not sexy:
- fix the re-typing
- agree your “official” systems
- tidy up reporting
- then start with small, safe AI helpers
Get those right, and you won’t “turn on AI”.
You’ll grow into it – calmly.
Where LevelUp and Ask Frank fit
- LevelUp is the guide that helps you climb this ladder in the right order. We help you design the stack, clean up the handovers, build the data hub, and shift the way work actually happens – so things stick when the consultants go home.
- Ask Frank is your Australian built copilot. Frank reads your data, policies and the business landscape, and turns them into clear steps, comparisons, actions, draft letters and checklists. Information and guidance – not legal representation – but a huge reduction in “I’m not sure, better start another spreadsheet”.
If your version of 4:02 pm feels too familiar…
Let’s map your current stage, set some simple exit criteria, and build a 90-day plan that pays for itself in the next 90.
Stop guessing with HR and IR. Ask Frank.
And if you need hands on the wheel, embed a LevelUp Hero and get the work done.