Product · HR · Build vs Buy October 2026

Building an HR Platform
In-House

Every company eventually hits a subscription tool that costs more than it gives back, or that just will not bend the way the business actually works. This is the method I used to replace one such tool, a system for employee records and leave approvals, with an in-house application, and the decisions that mattered far more than the code.

Build or Buy, Honestly

The honest starting point is not "we can build this ourselves", it is "should we". A subscription tool you can set up in an afternoon is almost always cheaper than engineering time, until it is not. The tipping point is usually one of three things: the per-user price stops matching the value, the tool refuses to model a process the way the business actually runs it, or the data you care about lives somewhere you cannot freely query. When two of those three are true, building starts to make sense.

I wrote the decision down in plain language before writing any code, because "we were annoyed with the old tool" is not a reason, and in six months nobody remembers the real one. A written build versus buy note is also what you show management when they ask, a year later, why this exists.

LessonBuild versus buy is a cost question, not an ego question. Count the hours honestly, including the years of maintenance after launch. If the only win is "it is ours", buy. If the win is control over the workflow and the data, build.

Model the Workflow, Not the Old Screens

The biggest trap when you replace an existing tool is rebuilding its screens one for one. The old tool's layout is the result of its own history and compromises, not a description of how your company works. So I started from the workflow on paper: who requests what, who approves it, who needs to see the result, and what has to be true before each step can happen.

Only after that did I think about screens. Half of the old tool's features turned out to be things nobody used, and two things people did every week were buried three clicks deep. Modelling the workflow first is what let me drop the first and surface the second.

Choose a Boring, Familiar Foundation

For the base I chose a boring, familiar platform rather than the most exciting one. The app needed user accounts, roles, an admin area, and a database, all of which a mature platform already gives you for free and, crucially, has hardened over years. That meant I could spend my time on the parts that are specific to us, the approval logic and the records, instead of rebuilding login and permissions from scratch.

A non-developer colleague can also manage users and settings through an admin screen they already understand, which matters more than any framework benchmark once the app is live and I am not the only person who can touch it.

LessonThe exciting choice and the right choice are rarely the same. Pick the foundation that lets you write the least code for the part that is actually yours, and that someone other than you can keep running.

The Data Model Is the Product

With an app like this, the data model is the product. Everything else is a view onto it. I spent real time getting a few things right: an employee record that is the single source of truth, a request that carries its own state (submitted, approved, rejected, cancelled) and its full history, and balances that are calculated from records rather than stored as a number someone can overwrite.

The moment a balance is a stored number instead of a sum of events, it starts drifting, and then nobody trusts it. Model the events, derive the totals. A balance you can always recompute from first principles is a balance people will believe.

Roles and the Approval Chain

Leave approval is really a permission problem wearing a calendar. A person can see and do different things depending on who they are: an employee sees their own requests and balances, a manager sees and decides on their team's, an administrative role sees everyone and can correct mistakes. I kept these as a small, explicit set of roles rather than a pile of individual flags, because every extra special case is a future bug.

The approval chain itself is data, not code: who approves for whom is a setting. That way a reorganisation is a configuration change someone makes in the admin area, not a line of code and a redeploy.

LessonIf "who can do this" lives in code, every org change is a developer ticket. Put the org chart and the approval rules in data, and the business can change itself without waiting on you.

Migrating the Records People Already Trust

A new system earns trust by agreeing with the old one on day one. Before switching anyone over, I imported the existing records and balances and checked that the numbers matched what people already believed to be true. Where they did not match, that was a finding about the old data, not something to paper over.

I also kept the import repeatable, so I could run it against a copy as many times as I needed and only point it at the live system once I was sure. The goal was simple: on the first morning, every person who logged in saw exactly the balance they expected.

Ship a Slice, Then Widen

I did not try to launch the whole thing at once. The first release did one complete workflow end to end, requesting and approving leave, for one group of people. That slice was small enough to get right and real enough to prove the model. Everything after that, more record types, reports, edge cases, went out as small updates on top of a thing that already worked.

Shipping a narrow slice that is genuinely finished beats shipping a wide one that is almost done, because "almost done" is where projects quietly die.

LessonA feature that works for ten people is worth more than five features that half-work for everyone. Finish a slice, put it in real hands, then widen. The feedback from one real workflow is worth a month of planning.

What Actually Mattered

The code was the smallest part. What mattered was deciding when building was genuinely the right call, refusing to copy the old tool's screens, modelling the data as events rather than overwritable numbers, keeping roles and approval chains as configuration, and earning trust by matching the old numbers before the switch-over.

Do those, and the application almost writes itself. Skip them, and no amount of clean code saves you.