// Still Done By Hand
The report rebuilt every Monday, the data retyped from one system into another, the request routed by whoever notices it first. We automate the repeating work and connect the tools you already pay for. It starts with a free automation map, delivered in five working days, that's yours to keep whether or not you hire us.
Somebody exports it, pastes it into a spreadsheet, formats it the way the recipient likes, and sends it. It takes an hour, it happens fifty times a year, and it is identical every time.
A person is the integration. Data gets retyped from one tool into another, so the second one is only ever as current as the last time somebody had a spare afternoon. Every retype is also a chance to fat-finger a number.
Email, chat, a form, someone walking over. Then they get read, categorised, assigned and chased by hand. Nothing is lost on purpose; things are lost because routing is a person's memory.
It started as one person's workaround and became load-bearing. The formulas are undocumented, the person who wrote them may have left, and nobody wants to be the one who breaks it.
See Project Rescue →Other work that belongs on the map
// The Starting Point
Free
5 working days turnaround
Most automation pitches start with a tool. This starts with arithmetic: what your team actually does by hand, how many hours a month it costs, and which of it is worth removing first.
We count the hours before we build anything. Every manual step gets a frequency and a duration, so the business case is arithmetic rather than our opinion.
It's a document, not a demo. There's nothing to buy, no platform to commit to, and no licence to sign before you know what it's worth.
Fixed scope and a fixed date. Five working days from the walkthrough, so it can't drift into a billable discovery project.
What you get
A few sentences is enough. Leave the budget on “not sure yet”.
A few sentences in the form is enough: the task, roughly who does it, how often. Leave the budget on “not sure yet”. The map costs nothing.
The person who would lead the work, not a salesperson. If a map is the right first step, we set up the walkthrough. If it isn't, we tell you that instead.
An hour or two with the people who actually do the work. Read access to the systems involved helps, but we can make the map without it.
Written down, sorted by hours a month, with a verdict on every item. Yours to keep, whatever you decide next.
Illustrative: invented tasks, real format
Orders retyped from the online shop into accounting
WhoAdmin
How oftenDaily
Each time20 min
Hrs / month≈ 7
VerdictAutomate first. Both tools can already export and import.
Weekly sales report rebuilt in a spreadsheet
WhoOperations
How oftenWeekly
Each time1 hr
Hrs / month≈ 4.3
VerdictAutomate next, with a scheduled query and an email.
Supplier price list updated by hand
WhoPurchasing
How often4× a year
Each time3 hr
Hrs / month≈ 1
VerdictLeave it. It will never repay the build.
Three ways forward, and one of them is doing it yourself. We'd rather you automate the right two things than buy a programme of work you didn't need.
It's a deliverable, not a sales call. If you have people who can build from it, they now have a prioritised list and an hours figure to justify the time. You owe us nothing further.
Pick the single step eating the most hours and we'll scope that alone. One automation, one price, running and documented before you decide about the rest.
We work down the list and stay on to keep the automations alive as your tools and processes change. Automation that nobody maintains quietly stops running.
See Managed DevOps →AI is the multiplier here, never the title. Most of what we build is plain workflows, queries and scripts, because they are cheaper to run and far easier to predict. AI gets used where the input is genuinely unstructured, and it has to earn that.
Before we reach for AI, we ask whether the problem actually needs it. Often a plain workflow, a database query, or a simple script is cheaper, faster, and more predictable. When it is, we'll say so.
The closer AI sits to your customers, your money, or your data, the more scrutiny it gets before it ships. In some places it doesn't ship at all.
Every AI-assisted decision has a named engineer behind it. When you ask why the system did something, you get an answer from a person, not a shrug at a model.
If AI adds cost, risk, or complexity without earning it back, we'll recommend building without it. You're paying for the right tool, not the fashionable one.
We won't publish a rate card, because any number we put here would be wrong for most of the people reading it. What we will do is tell you exactly how the number gets decided.
Always, and with no obligation. Whatever we find, you get it in writing. It's yours to keep whether or not you ever hire us, even if you hand it to another developer.
Once we've seen the codebase or the process and the scope is clear enough to commit to, you get one number and one timeline. No hourly meter, no surprise invoices.
Some work can't be honestly estimated up front, because of deep unknowns in an inherited system or a scope that will move as we learn. There we bill hourly, because padding a fixed price for that risk means you pay for it whether it happens or not.
Some work isn't a project with a finish line. It's keeping software shipping, watched, and healthy month after month. There we agree a monthly scope and one monthly price up front, and you can step away on 90 days' notice. No multi-year lock-in.
No speculative proposals for work you haven't decided on. Tell us you want it built and we'll price it properly. That's also why we look first.
// The Part Most Agencies Leave Out
Automating a broken process doesn't fix it. It makes it fail faster, more often, and further from anyone who would notice. Some steps exist because two teams never agreed on who owns something, and the honest fix is that conversation, not a workflow that papers over it. Others happen three times a year and will never repay the cost of building them.
The map says so where it's true. A shorter list of automations you actually keep is worth more to you than a long one we get paid to build.
Get a free automation map →If you've brought in outside engineers before, you know where it goes wrong: the senior on the sales call isn't the one doing the work, the code lives in someone else's account, the price moves, and your data is shared before anything is signed. So those four go in writing first.
On the first call, you meet the senior engineer who will lead the work, by name. They stay accountable for all of it to the end, including work by any developer we bring in. No handoff to a stranger once the contract is signed.
You own the code the moment it's written, not when the final invoice clears. It lives in your repository, under your account, documented so any developer can pick it up. No lock-in, and nothing held hostage.
It can be a fixed price, hourly, or a fixed monthly fee, whichever fits the work. You see the number and how it's billed before you commit, and it doesn't change unless you agree to the change first.
Ask and we'll sign yours, or send ours, before you share a repository, a database, or a business plan. We'd rather do the paperwork first than ask you to trust us with it.
Almost never, and we'll argue against it if you suggest it. The tools you already pay for usually have an API, an export, or a webhook nobody has ever switched on. Connecting what you own is cheaper than migrating, it doesn't cost you a retraining cycle, and it doesn't make us the reason your team has to learn a new system.
Then the automation changes with it, which is why we write down how each one works and where it's configured rather than leaving it in our heads. Automations that only their author understands are how a business ends up with a second undocumented system. We're not going to hand you one of those while removing another.
Every automation we build logs what it did and raises something a human sees when it fails: a ticket, an alert, or a message in the channel your team already watches. Silent success and silent failure look identical, and a pipeline that quietly stopped two weeks ago is worse than no pipeline at all.
Whichever is right, and most of the time it's the boring answer. A scheduled query, a plain workflow or a small script is cheaper to run, easier to reason about, and far more predictable than a model. We use AI for the parts that genuinely need judgement about unstructured input, such as reading a document, classifying a message or drafting a first response. We'll tell you plainly when a problem doesn't need it.
That's your decision, not ours, and it's worth being honest that it's the question the team will actually be asking. What we can tell you is what we usually see: the hours come off the parts of the job nobody wanted (retyping, chasing, reformatting), and the same people end up handling the exceptions, which is the part that needed a human in the first place.
Five working days from the walkthrough. What we need is an hour or two with the people who actually do the work, not a written brief from a manager. The interesting steps are the ones that never made it into any process document. Read access to the systems involved helps, but we can produce the map without it.
Per automation, once we've seen the real process. Most individual workflows are predictable enough to quote as a fixed fee, with one number and one timeline. Where a system is undocumented or an API turns out to be a fight, we bill hourly for that piece instead of padding a fixed price against a risk that may never materialise. And we only quote the ones you've told us you want.
// Free, No Commitment
Find out where
the hours go.
Tell us what your team still does by hand. We'll put hours against it and tell you what's worth automating first. You get the map in five working days, at no cost, and it's yours either way.
