Skip to content

Service

Workflow Automation

We automate the repeated handling between your systems and your people, with retries, visibility and an off switch, so the work happens whether or not anyone remembers it.

Laptop on a software development workspace

The problem

What usually goes wrong

Every business runs on a set of small obligations. Chase the quote after three days. Send the reminder the night before. Tell dispatch when the part arrives. Each one takes two minutes and each one is forgotten sometimes.

The usual fix is a reminder in someone calendar, which works until they are on holiday, and a rule in an email client, which nobody else can see.

Automation is worth building when the trigger is objective, the action is defined, and the cost of missing it is real.

Scope

What we deliver

  • Process mapping

    The actual sequence of a job, including the handoffs that happen in chat and the steps people do without being asked.

  • Trigger design

    What starts each automation: a record change, an inbound event, a schedule, or a condition that becomes true. Ambiguous triggers are the main source of duplicate sends.

  • Action implementation

    Email, messages, record updates, task creation, document generation and calls into other systems, each idempotent.

  • Branching and conditions

    Rules for the exceptions that really exist, rather than a flow that only covers the standard case.

  • Observability

    A view of what ran, what it did, what failed and what is waiting, so an automation is inspectable rather than mysterious.

  • Controls

    Per automation pause, send limits, quiet hours and suppression rules so an error cannot email the same customer forty times.

Method

Technical approach

We map the process from evidence rather than description. What people say happens and what the timestamps say happens differ, and the automation has to fit the second one.

Triggers are defined precisely, with an explicit guard against re firing. A state transition fires once, recorded against the record, so an edit that touches the same field again does not repeat the action.

Every action is idempotent and carries a key derived from the record and the step. A retry after a timeout does not send a second message or create a second task.

Failure is expected. Retries use exponential backoff with jitter, a provider outage opens a circuit breaker, and anything that exhausts its budget lands in a queue with the payload and the error where an operator can see it and replay it.

Automations are built with limits from the start: rate caps per recipient, quiet hours, suppression for unsubscribed or closed records, and a single control to pause a flow without a deployment.

Handover

Deliverables

Everything below is yours at delivery, including the intellectual property. Sawhorse keeps nothing.

  1. 01Process maps for the workflows in scope
  2. 02Automation definitions with explicit triggers and guards
  3. 03Idempotent actions with keyed deduplication
  4. 04Retry, backoff and dead letter handling
  5. 05Run history and failure queue with replay
  6. 06Rate limits, quiet hours and suppression rules
  7. 07Pause controls per automation
  8. 08Source code or exported orchestrator definitions, plus a runbook

FAQ

Questions people actually ask

How do you stop an automation sending the same thing twice?

Each action carries a key made from the record and the step. The first run records it, and a retry with the same key is a no operation. State transitions are recorded too, so a repeated edit does not re trigger.

What if a customer replies to an automated message?

Replies route to a real inbox or a task, and a reply suppresses the rest of the sequence for that record. An automation that keeps chasing someone who already answered is worse than none.

Do you use n8n or write code?

Both, chosen per workflow. An orchestrator is good for flows that change often and involve many vendor connectors. Code is better where the logic is intricate, the volume is high, or the behaviour needs tests.

Can we turn one off ourselves?

Yes. Every automation has a pause control that does not need a deployment, and the run history shows what it did while it was on.

What happens during an outage at a provider?

Work queues rather than disappearing. Once the provider recovers the queue drains, and anything past its retry budget is visible for an operator to replay or discard.

Who owns the automations?

You do. Code and orchestrator definitions are handed over, along with the runbook and the credentials, which live in accounts you control.

Let’s talk about the system you need.

Tell us where the current process breaks down. We can map the workflow, examine the integration requirements and define a practical scope for the build.

  • A mutual NDA is signed before project details are shared.
  • Scope is fixed in writing before any build starts.
  • You own the source code, the IP and the documentation at delivery.
  • Support plans are available and tailored on a discovery or technical call.