Information security for software delivery

ISO/IEC 27001
ISO/IEC 27001 certified
Before automation
Mapping the process as it is actually run, not as it was filed
The build starts away from the keyboard. These steps decide what the software will be, and they are where most of its eventual quality is determined.
Sit with the people who run it
We follow real requests through the process with the staff who handle them, and record what actually happens — including the WhatsApp message that unblocks step four. The real process, on paper for the first time.
Collect the exceptions
Every "except when" is written down with its frequency and its cost: the rejected invoice, the approver on leave, the request withdrawn halfway, the decision that had to be reversed. The exception list — usually longer than the happy path, always more valuable.
Fix before you freeze
Steps that exist only because of an old constraint are removed with the owners' agreement now, because software makes whatever it encodes permanent. A process worth encoding, not a fossil of the old one.
Design the states and the trail
The process becomes a state model in which every path — normal and exceptional — is a defined transition, and every transition writes who acted, when, and on what authority. A specification the auditors will like as much as the developers.
What sinks these projects
Four ways approval systems fail their first real month
Workflow software rarely fails in the demo. It fails when the process meets the cases the demo never contained.
- 01
The happy path was the whole design
Submitted, approved, done — and then the first rejected item has nowhere to go, so staff route around the system, and the workflow becomes a form in front of the old chaos.
- 02
Humans modelled as instant systems
A system step answers in milliseconds; a human step waits for a person who is in a meeting, on leave, or gone. Without delegation, reminders and escalation clocks, every absence is a stuck request.
- 03
The audit trail assembled afterwards
When the trail is reconstructed from logs on demand, the one question that matters — who approved this, under which limit, seeing what — cannot be answered with confidence. The trail must be written by the transition itself.
- 04
No way to undo what the process did
Real operations reverse decisions: an approval granted in error, a payment recalled. A workflow with no designed reversal forces administrators to edit the database — the exact loss of control the system was bought to end.
Build or configure
When configurable workflow tools beat custom code, and when they stop
We build custom workflow software and still recommend off-the-shelf tools for a large share of processes. The dividing line is how far your real process is from the tool's assumptions.
| Option | Fit to your exceptions | Speed to a working process | Integration depth | Who evolves it later | Best for |
|---|---|---|---|---|---|
| Configurable off-the-shelf | Excellent while your process resembles the templates; strained when your exceptions and authority rules do not fit the boxes the vendor drew. | A standard approval flow can be live in days, which for many back-office processes is the right trade. | Strong for the systems the vendor already connects to; harder at the edges — a legacy application, an unusual data source, a local platform. | Business administrators adjust it within the tool's limits; beyond them you are queuing for the vendor's roadmap. | Standard processes — leave, purchase requests, document sign-off — where your rules fit common patterns. |
| Custom workflow software | The exceptions, delegation rules and reversals are designed in exactly as your operation runs them, because they are the specification rather than a workaround. | Weeks to the first process, since the state model is built rather than picked — the price of the fit. | Reaches whatever your systems expose, including the old and the local, with the workflow reading and writing them directly. | Your team owns the code and the model; changing a rule is a release you control, not a feature request you wait for. | Processes that are your operation's edge — heavy exceptions, deep integration, rules that are genuinely yours. |
Our role
Joining human judgement and system steps in one accountable flow
- 01
The state model, built for both
System steps validate, calculate and update records; human steps decide. We design each kind for what it is — instant transitions for the systems, and queues, delegation and escalation clocks for the people.
- 02
The trail as a by-product of use
Every transition records actor, time, data seen and authority used, at the moment it happens. When an auditor asks who approved a payment and what they were shown, the answer is a query, not an investigation.
- 03
An honest recommendation first
The mapping workshop ends with a build-or-configure recommendation per process. Where an off-the-shelf tool fits, we say so and can implement it — selling custom code into a standard process would cost you the difference for no gain.
What gets approved, by whom and within which limits are your operating rules; the system we leave behind enforces them, records them, and lets your team change them without calling us.
Common questions
What buyers ask
Why insist on mapping our process before building the workflow system?+
Because the software will enforce whatever it encodes, permanently and at scale. If we encode the documented process, the system fights the real one from day one: staff meet steps that do not match how work actually moves, exceptions have no path, and the workarounds reappear — now outside the system, invisible to the audit trail. Mapping first surfaces the gap between the filed process and the run process, lets the owners fix what should be fixed before it is frozen in code, and produces the exception list that is the true specification. A week of mapping routinely changes the build more than a month of development would.
How should workflow software handle the exceptions our team currently resolves by phone?+
By making each one a designed state instead of a dead end. The phone call exists today because the exception has no path: the invoice mismatch, the missing document, the approver who needs one more piece of context. In the system, each becomes an explicit transition — send back with a reason, request information, escalate after a deadline, override with recorded authority — so the case moves inside the workflow with its history attached rather than leaving it. The phone does not disappear; the conversation still happens when judgement needs it. What changes is that its outcome is recorded as a transition, so the trail stays complete even when the resolution was human.
When is an off-the-shelf workflow tool the better answer than custom software?+
When your process is genuinely standard and your rules fit the tool's patterns — leave requests, routine purchase approvals, document sign-off chains. For those, a configurable tool is live in days, costs a subscription rather than a build, and its limits will likely never be met. Custom earns its price where the process is your operation's edge: exception-heavy, deeply integrated with your own systems — including legacy ones — or governed by authority rules no template anticipates. Many organisations correctly run both, and the expensive mistakes are symmetrical: forcing a distinctive process into a template it does not fit, or paying for custom code where a template was enough. Our mapping workshop exists to make that call per process, with reasons.
In this cluster
A mapping workshop on one real process that produces the state model, the exception list and an honest build-or-configure recommendation.
Plan it with us