The spreadsheet that runs the department.
We turn it into an application: same rules, single data, permissions, history. And the spreadsheet goes back to what it should have stayed — a tool for analysis.
We map and redesign the way your organisation works, then build the operations application that carries it — wired into your systems, designed for your teams, with AI added when a processing ceiling calls for it.
A shared spreadsheet that has become critical. The same information keyed in three times. Approvals by email. A memory that fits in the heads of two people. It works — until the volume rises.
Each piece of information entered once. Rules written down and versioned. Approvals logged. Your existing systems wired in, no re-keying. It stands on its own — without AI.
When the volume exceeds what people can handle by hand, an AI layer is added to the application: reading documents, preparing case files, routing. Controlled, traceable, reviewed. When it is warranted — and only then.
Drag the handle. On the left, the process as it survives in most organisations. On the right, what we make of it.
Six situations we find in almost every organisation that calls us. And what we do about them.
We turn it into an application: same rules, single data, permissions, history. And the spreadsheet goes back to what it should have stayed — a tool for analysis.
We take over its data and replace it increment by increment, without downtime. Teams move screen by screen, not all at once on a Monday morning.
We build the integration: no more Friday export, no more Monday re-keying. A good off-the-shelf tool deserves to be properly wired in.
We automate what can be automated. When the human ceiling is reached anyway, AI takes the reading and the sorting — and your case handlers keep the decision.
Every action logged, every decision justified, every rule dated. The records an audit asks for come out in one click, not in three weeks.
We find the real processing ceiling, we stabilise the process, then we put AI where it gives hours back — not where it looks good.
Seven families of process, across different sectors. Pick one: the ground, what we build, what it changes for the teams.
Thousands of applications a year handled by hand, each with its documents, its scales and a decision to justify against a regulation that changes every year.
Online submission, automatic eligibility checks, calculation against the scale in force, multi-hand approval, justified decisions generated, payment instruction passed to accounting.
Case handlers decide instead of re-keying. Next year's regulation is configured in a few days, not through a rebuild.
The organisations are not named: this work belongs to those who commissioned it. References are given on a call, with their agreement.
In order, with the timing. You can stop at any step; so can we.
Not an automatic acknowledgement. Three questions about your situation, and a proposed time slot.
You describe, we question. If an off-the-shelf product is enough, we say so here, we give you its name — and we offer to wire it into the rest if that helps.
The process as it is actually practised, next to the people who do it. Friction, manual tasks, duplication, error risk — mapped and costed in hours.
Target process, scope, increments, timeline, firm budget per increment, named team. You decide with the document in hand, not on an impression.
The first increment is used by your teams while the next one is built. Training, data migration, then handover: code, data, documentation.
They appear in the scoping document, before the first line of code. That is where the difference lies between software you own and software that owns you.
| Clause | With Peregrine | What you see elsewhere |
|---|---|---|
| Who you deal with | The person who ran the analysis writes the code and stays until handover. | A salesperson sells, a project manager relays, a team you will never meet does the work. |
| The source code | In your repository from the first increment delivered. Ownership, not a licence. | Owned by the supplier, granted for as long as the maintenance contract runs. |
| The business rules | Configurable and dated. Next year's scale is changed without us. | Hard-coded. Every change of regulation becomes another quote. |
| AI | Added once a processing ceiling has been measured, and only there. | Put forward in the sales proposal, before anyone has seen the process. |
| The end of the engagement | Documentation, reproducible environments, training. Any competent developer can take over. | A dependency you discover the day you want to change supplier. |
The short answers. The long ones take thirty minutes.
There is no catalogue price because there is no catalogue product. What we do commit to: a firm budget per increment, in writing, before the first line of code.
And if the investment does not pay for itself, we say so on the first call, with the figures.
A few weeks for a targeted integration, three months for one department's process, more than a year for the application that carries the whole business.
In every case, the first increment is in production well before the end.
Yes. A good off-the-shelf tool stays in place; we build what is missing around it and the integration between the two. We only replace what is holding you back.
Yes, and it is a large part of our work. Spend tracked per budget line and per funder, eligibility evidence, documents attached to the case file, interim reports produced from operational data rather than reconstructed by hand.
The constraint we hear most often is not volume: it is having to account for decisions years later, under rules that have changed since. That is exactly what versioned rules and a complete audit trail are for.
Because a model reading documents inside a process where nobody knows who approves what produces errors faster, not fewer.
The application first: single entry, written rules, logged approvals. Then AI has something to stand on — and someone to check it.
A team named in the scoping document, reinforced on some projects by developers we choose and supervise. No offshore floor, no anonymous subcontracting.
You have the code, the data, the documentation, and an environment any competent developer can pick up.
That has been the goal since day one, not an exit clause.
Five lines are enough for us to know whether we can be useful — and to tell you straight if we cannot.
The process, in one sentence: what goes in, what comes out, who is involved.
The volume: how many operations a month, and the trend.
Today's tools: spreadsheet, old software, email, paper — no need to be embarrassed.
Who decides: the person who will settle the trade-offs.
Looking to structure your sales and acquisition instead? That is our other division.
Peregrine Growth ↗