The spreadsheet that runs your business shouldn't be one bad copy‑paste away from a problem.
hij2 builds custom internal applications for small and mid‑sized operations teams — replacing brittle spreadsheets, manual handoffs, and disconnected tools with software that fits how your team already works.
One senior engineer. 20 years of building software. No handoff to a junior team.
Signs a process has outgrown its spreadsheet
A spreadsheet that's still in use after five years is usually evidence of a process worth keeping. The problem is rarely the process — it's that the tool stopped being able to carry it.
- One person owns the file. When they're out, the process stalls, and nobody else is confident enough to touch the formulas.
- Numbers disagree. Two people run the same report and get different answers, so a meeting gets spent reconciling instead of deciding.
- The same data is entered twice. It's keyed into one system, exported, cleaned, and re‑keyed into another.
- Errors are found late. A wrong quantity or a stale price surfaces at invoicing, after it has already cost something.
- Status lives in email. "Where is this order?" takes three messages and a scroll through a thread to answer.
- Growth makes it worse. More volume means more tabs, more manual checks, and more overtime — not more capacity.
What a fitted internal application changes
The goal isn't new technology. It's a shorter path between work happening and everyone being able to see it, trust it, and act on it.
Fewer errors
Validation, required fields, and calculations that live in one place instead of in each person's copy of the file.
Faster cycle times
Handoffs that used to be an email and a wait become a status change the next person can see immediately.
Reporting you trust
One source of record, so the weekly numbers are pulled rather than assembled the night before.
Less manual work
Re‑keying, copying between systems, and reconciliation get automated where the rules are clear.
Outcomes depend on the process and the starting point. Any specific targets for your project are estimated during discovery and written into the delivery plan as measurable acceptance criteria — not promised up front.
Three ways to start, in order of commitment
Most engagements begin with a short, fixed‑scope discovery sprint. Nothing large is quoted before the process is understood.
Discovery & Architecture Sprint
A fixed‑fee engagement that maps the current process, defines requirements, surfaces risks, and produces a costed delivery plan you own — whether or not you build with hij2.
DetailsCustom Application Build
The agreed solution, delivered in visible milestones with regular demos and acceptance criteria written in your team's language, not in technical terms.
DetailsOngoing Engineering Partner
A monthly retainer for support, fixes, small improvements, and the next round of changes — so the application keeps up as the process changes.
DetailsTwenty years of engineering, pointed at one problem at a time
hij2 is a solo consultancy. The person who scopes your project is the person who builds it and the person you call when something breaks. That's a deliberate limit: fewer clients at once, and no cost of translating requirements through a delivery team.
Long experience mostly shows up as things that don't happen — fewer surprises late in a build, fewer rewrites, and an early, direct conversation when something in the plan doesn't hold up.
- The smallest useful solution first. If a two‑week integration solves it, that's the recommendation — not a platform.
- Your spreadsheet is evidence, not a mistake. It encodes real rules the team worked out. Those rules carry into the application.
- Fixed scope before fixed price. Build pricing is committed after discovery, when scope, acceptance criteria, and dependencies are known.
- Plain language. Technical decisions get explained in terms of cost, speed, risk, and what you'll be able to change later.
- You own the output. Code, data, and documentation are yours, in your accounts, from the first milestone.
Common questions
We're not sure whether we need software or just a better process.
That's a normal place to start, and it's what discovery is for. A meaningful share of operational problems are solved by a process change, a single integration, or a report — not a new application. You'll get a straight recommendation either way, including the recommendation to build nothing.
Do we have to replace our existing tools?
Usually not. Most projects connect what you already run — accounting, CRM, inventory, a shared drive — and add only the piece that's missing. Replacing a working system is the expensive option and is proposed only when keeping it costs more.
How long does a project take?
A discovery sprint is measured in weeks. Builds are scoped into milestones so something usable arrives early rather than at the end. Actual timelines are estimated during discovery, against your real requirements.
What does it cost?
Discovery is a fixed fee agreed before it starts. Build pricing is quoted after discovery, when the scope is known — committing to a fixed build price before that is how projects go wrong for both sides. Retainers are a flat monthly fee.
What happens if we stop working together?
You keep everything: source code, data, documentation, and accounts, all in your own name. The handover notes are written as the build goes, not assembled at the end.
Start with the process, not the software
Describe the process that's causing the most rework right now. You'll get a written read on whether it's a workflow fix, an integration, a report, or an application — and what a first step would cost.