I ripped out our third-party timesheet system and rebuilt it natively in Salesforce.
Three months ago, I did something that most sensible people would probably avoid.
I ripped out a third-party timesheet system that technically worked…
and rebuilt the entire thing natively in Salesforce.
Thanks for reading Phil's Substack! Subscribe for free to receive new posts and support my work.
Not because the old system had failed.
Not because it was “bad”.
It did what it said on the tin.
But it forced us into someone else’s idea of how timesheets, invoicing, and payments should work — not how they actually work inside a veterinary locum agency.
And over time, that gap mattered.
“It works” isn’t the same as “it fits”
Our previous system handled the basics:
locums submitted timesheets
practices approved them
invoices were generated
But everything around that core flow felt fragile.
Exceptions were awkward.
Corrections were painful.
Edge cases required manual intervention.
And the system never really understood the relationships between:
locums
placements
rates
timesheets
invoices
and payments
That’s tolerable if timesheets are a small part of your business.
They aren’t for us.
Timesheets sit right at the intersection of compliance, payroll, invoicing, cash flow, and trust. Errors aren’t just annoying — they’re expensive, reputationally damaging, and time-consuming to unwind.
So eventually, I stopped asking “How do we work around this?” and started asking:
Why don’t we just build the thing we actually need?
Building it properly meant building it from scratch
I didn’t clone an existing system.
I didn’t follow a reference architecture.
I didn’t try to “replicate” what we already had.
I started from first principles:
What actually happens in the real world?
Who should be able to do what — and when?
Where do mistakes usually occur?
What should be impossible, not just discouraged?
And then I built around that.
The result:
a fully Salesforce-native timesheet system
tightly integrated with placements, rates, invoices, and suppliers
designed specifically for locum recruitment
with financial controls baked in from day one
The biggest lesson: simplicity is deceptive
From the outside, the system looks intentionally boring.
For locums:
submit timesheets
For practices:
approve timesheets
For internal users:
process invoices
That’s it.
No instructions.
No training guides.
No “please email us if something goes wrong”.
But that simplicity comes at a cost.
Because making something simple for users makes the backend brutally complex.
Behind the scenes, that meant:
heavy validation rules
status-driven field locking
guardrails everywhere
structured, opinionated flows
duplicate prevention
correction handling
edge-case logic you hope never triggers… but know eventually will
The system doesn’t rely on people “doing the right thing”.
It makes the wrong thing hard — or impossible.
Automation wasn’t optional
One rule I set early on:
if a process relies on instructions, it’s already broken.
So automation wasn’t a “nice to have”.
We built:
automatic submission reminders
automatic approval reminders
clear status progression
process-led internal handling
The outcome surprised even me.
Internally, anyone can now manage timesheets and invoicing after a few hours of training.
No tribal knowledge.
No “only Sarah knows how this works”.
No quiet workarounds.
The system leads the process.
The unexpected pain point: PDFs
I assumed PDF generation would be trivial.
It wasn’t.
Some vendors quoted £17,000 per year, with usage-based pricing and wildly over-engineered solutions for what we actually needed.
After far too much time looking at options, I eventually found a solution that:
took under two hours to configure
does exactly what we need
costs £60 per user per year
No bells.
No whistles.
Just reliable document generation.
That contrast alone was eye-opening.
Licensing nearly derailed the whole thing
This was the part I didn’t see coming.
Salesforce Enterprise orgs include 20,000 free External App logins — but not Experience Cloud customer licences, which cost around £4 per user per month.
For a locum business, that adds up quickly.
With careful design, strict permissioning, and a lot of testing, I managed to:
use the free External App licences
maintain proper security and privacy
avoid exposing anything users shouldn’t see
and save thousands per year in licence costs
It wasn’t trivial — but it was worth it.
We tried to break it before it broke us
We ran the new system in parallel with the old one for over a month.
Deliberately.
And aggressively.
We:
stress-tested edge cases
forced corrections
pushed invalid states
tried to break flows
tried to confuse users
Only when it consistently behaved as expected did we switch it on fully.
It’s now been live for over a month — and it’s running exactly as intended.
Still iterating — but proud of this one
It’s not “finished”.
It never will be.
Next up is consolidating self-billing invoices and tightening a few financial loops.
But this has been one of the most satisfying builds I’ve done — not because it’s flashy, but because it disappears. It just works.
The real takeaway
Build for your real-world process — not someone else’s generic one.
Off-the-shelf systems are great until they aren’t.
And when your business sits in the gaps between “standard” workflows, those gaps become painful very quickly.
Happy to share lessons learned — or scars 😅
If you’re building anything similar, you’ll probably earn a few of your own.
