Case studies · Automation · Techniques

How we keep automation safe to run every day.

Each technique below appears in the case studies. For each one: what it is, why it matters, and how we apply it on new work.

Idempotency keys and safe re-runs

What it is
Every incoming request or scheduled result carries a key that identifies it. The key is checked before anything is written, and summary rows are written with an upsert on a fixed key.
Why it matters
People double-click, browsers retry and schedules overlap. Without a key, each of those becomes a duplicate ticket, payment or alert. With one, running the same thing twice is harmless.
How we apply it
We decide the key for every write before we build the step that makes it, and test each workflow by sending the same request twice.
Where it appears

Validation at the point of entry

What it is
Requests are checked where they arrive: who sent them, whether the action is allowed, whether required fields are present and in range. Anything that fails is refused before it reaches a database.
Why it matters
Bad data is cheapest to stop at the door. Once it is in the database it spreads into reports, messages and other systems.
How we apply it
We keep shared secrets and API tokens in the automation platform's credential store, never inside workflow steps; we use long random values and rotate them; and where a provider signs its webhooks, we verify the signature.
Where it appears

Careful matching instead of duplicates

What it is
Records are matched in layers (an account reference first, then email, then phone) with empty values left out of the match, and repeats are recognised rather than recreated.
Why it matters
One person with two records breaks every count, every report and every message sent to them. Matching on an empty value is a classic way to attach everyone to the same record.
How we apply it
We agree the matching rules with the people who own the data, and we never overwrite details staff may have corrected by hand.
Where it appears

Reconciliation guards

What it is
A separate scheduled job compares what should have happened across systems with what actually did, and records each gap as an incident with a history.
Why it matters
Individual automations fail quietly. A guard that checks the outcomes, not the automations, is how you hear about a problem before a customer does.
How we apply it
For any process where a silent failure costs money or access, we propose a guard alongside it, and we make sure a source that cannot be read is reported, never treated as "all clear".
Where it appears

Batching, throttling and retries

What it is
Large writes are split into groups the target system accepts, paced to stay inside its rate limits, and retried a set number of times. Failures are classed as temporary or permanent.
Why it matters
Most platforms limit how much you can write at once. Ignoring that turns a large job into a half-finished one.
How we apply it
We answer the person who started the job straight away and do heavy work in the background, and we design what happens when a batch still fails before we design the happy path.
Where it appears

Server-side scoping and role sync

What it is
What a person can see is decided on the server from their role and assignments, and access changes in one system are carried to the others automatically.
Why it matters
If the browser receives every record and hides some, the records are not protected. And access that depends on someone remembering to change a role will, sooner or later, not be changed.
How we apply it
We build filters from the caller's assignments on the server, and role changes only go ahead when the person still holds the role we expect, so a manual change is never overwritten.
Where it appears

Precomputed snapshots for dashboards

What it is
Figures are calculated on a schedule from the source records and stored as a small set of keyed summary rows, which the dashboard reads directly.
Why it matters
Calculating live on every page view is slow and burns through API limits. A snapshot loads instantly and is always rebuilt from source, so it cannot drift.
How we apply it
We show when each snapshot was built, and offer an on-demand refresh that runs exactly the same calculation as the schedule.
Where it appears

Passwordless access with one-time codes

What it is
A short code is sent to an address already on record, expires quickly, allows a limited number of attempts, and exchanges for a short-lived token that unlocks a narrow view.
Why it matters
Many people never set a password, and sharing personal details by phone or chat exposes them to whoever asks.
How we apply it
We generate codes and tokens with a cryptographic generator, store only what verification needs, return only whitelisted fields, and give the same answer whether or not an address exists.
Where it appears

A person decides where it matters

What it is
Automation does the gathering, checking and paperwork; a named person makes the decision, with a one-click way to approve, return, reject or cancel.
Why it matters
Some decisions carry money, reputation or judgement. Automating around the decision, not through it, removes the busywork without removing accountability.
How we apply it
We agree with you which steps need a person, and make sure the automation records who decided what and when.
Where it appears

Normalising messy, multilingual input

What it is
Fields are read under all their known names, cleaned of invisible characters, and converted to standard values, including Arabic and English spellings and Arabic-Indic digits.
Why it matters
Real forms arrive in mixed languages and formats. Matching and totals fail quietly when "the same" value is written three different ways.
How we apply it
We collect real examples of the input before we build, and keep all the cleaning rules in one place so they can be read and changed.
Where it appears

Explicit statuses and guards

What it is
Each item moves through named statuses (pending, in progress, done, failed, cancelled) and every change checks the current status first.
Why it matters
Explicit statuses make overlapping runs and double taps harmless, and they let anyone see exactly where an item stands.
How we apply it
We write the statuses down with you before building, and every failure path ends in a status a person can act on.
Where it appears

Alerts that say what changed

What it is
Alerts go out when something new happens, when an issue has waited long enough to need a reminder, or when it clears, together with a heartbeat that shows the job itself is running.
Why it matters
An alert on every run is ignored within a week. Silence is only reassuring if you know the job that would have spoken actually ran.
How we apply it
We route alerts to the people who can act on them, keep technical failures apart from business notifications, and include what to check next.
Where it appears

Configuration in one place

What it is
Table names, field references, schedules and limits live in one configuration step, referenced by stable IDs rather than display names.
Why it matters
Renaming a column or moving from a test table to a live one should be a one-line change, not a hunt through twenty steps.
How we apply it
We hand over every workflow with its configuration separated from its logic, and document what each setting does.
Where it appears

Want these applied to your process?

Describe how the work runs today. We will tell you which of these it needs, and what it would take.