nobody is watching
Automation is bought on trust long before it is bought on features. You are handing a team your invoices, your customer records and the parts of the job nobody enjoys — so it is fair to want to know how that team decides things when the meeting ends. This is that, written down.
What we hold to
Eight things we don’t argue about
None of this is aspirational. Every one of them is a decision we have already made in front of a client, usually the expensive way.
01
The work is the hours, not the software
Automation is only worth something if somebody's day changes. We measure a build by the work that stopped happening, not by the features that shipped — and if the hours don't move, it didn't work, however good the system looks.
02
Proof before promises
Nothing gets built on the strength of a deck. A working prototype against your own data comes first, so the decision to build is made on evidence. If the evidence doesn't hold, we say so before the invoice rather than after it.
- Prototype first
- Measured per release
- No is an answer
03
People are the point of the automation
We build systems that take work off a desk, not people out of a job. Routine work stops reaching your team; decisions still do. Anything unfamiliar stops and waits for a person, with the reason attached.
- Escalate decisions, not tasks
- Draft, never send blind
- Train the people who run it
04
Built for how business actually works here
Arabic and English side by side, regional documents, local suppliers, the working week as it is. Software that assumes otherwise is software a team quietly works around, and a workaround is just manual work with extra steps.
- Bilingual by default
- Your data, in your region
- Shaped to the process you have
05
Handed over, not held hostage
Source, infrastructure, documentation and a runbook are yours when the engagement ends. Clients who want us to keep tuning the system stay because the work is good, not because leaving would be expensive.
06
No big bang
Nothing goes live by switching the old thing off and hoping. Historic data moves across in stages with the current way still running beside it, until the new one is proven on real work rather than on a test plan.
07
Learning is the job, not a perk
Half the tools this work depends on were released in the last two years, and half of those will be gone in the next two. We would rather be corrected early than confident and late, so the default is to go and find out.
- Curiosity before certainty
- Evidence before opinion
- Corrected early over confident and wrong
08
Quiet work, held over time
The systems we are proudest of are the ones nobody in the business thinks about any more. Good automation is close to invisible — the only sign it is working is that the hours stopped disappearing and nobody had to be told why.
In practice
What that looks like on a Tuesday
01
Read the work first
Discovery before anything is built. We map what runs manually today and where the hours go, then propose against that map rather than against a product.
02
Scope small enough to prove
A build that can't be evaluated can't be trusted. Every stage is cut so there is something real to look at and a way to tell whether it worked.
03
Show, don't present
Working software at every checkpoint. A slide about what the system will do is not evidence that it does it.
04
The handover ships with it
Documentation, runbook and training are part of the build, not a phase that gets cut when the timeline tightens.
05
Say the unwelcome thing
If there is nothing here worth automating, that is the answer we give — early, and in plain terms, while it still saves somebody money.
06
Stay after launch
Monitoring, tuning and refining the rules are the engagement, not an epilogue to it. Handover is not where the work ends.
Still reading
We can't tell you whatthe next decade automates
Only that we intend to still be here when it does — reading the work before building against it, proving things before selling them, and handing over what we build to the people who have to live with it.
Or read how an engagement runs