How I work

Understand the process before touching a tool.

Most of the work in a good automation happens before anything gets built. This is roughly how I go from “we have this annoying process” to a system the team actually trusts.

  1. 01Understand the current process

    Before anything gets built, I want to see how the work happens today. Who does what, where things come in, which tools are already in use, and what people are tired of doing.

    A plain description of how the work runs now

  2. 02Map the manual workflow and friction

    I map it step by step, including the bits nobody writes down, like the WhatsApp message someone forwards or the sheet somebody checks every morning. That’s usually where the friction is.

    A workflow map with the bottlenecks marked

  3. 03Define the target system and boundaries

    Then I decide what the system should do, and just as important, what it should not do. Where does a person need to approve? What happens when data is missing? What counts as done?

    Target flow, exception paths and handoff points

  4. 04Build integrations and AI logic

    I build the workflow, connect the tools, and add AI only where it actually helps, like understanding a message or drafting something. Not everything needs a model.

    Working system in a test environment

  5. 05Test normal and failure scenarios

    Testing the happy path is the easy part. I test the annoying cases too: missing data, API errors, unclear messages, no availability, duplicates. Those are the ones that show up on a Monday morning.

    Scenario tests, including failure cases

  6. 06Connect it to the team’s existing tools

    The system goes live inside the tools the team already uses, so people don’t have to learn a whole new way of working just to benefit from it.

    Live system in your real tools

  7. 07Document, hand over and monitor

    I document how it works, what each failure path does, and who gets notified when something needs attention. Then I watch it run for real.

    Docs, alerts and a team that understands the system

→ Step 05, up close

Testing the annoying cases.

These are the failure scenarios from the returns workflow I built. Every one of them has a defined path, and some of them deliberately end with a person.

Where it happens
Step 02 Eligibility check
What goes wrong
Request doesn’t meet the policy
What the system does
Instead of auto-rejecting, it goes to manual review so a person makes the call.
Who handles it
A person: support team

+ Principles

What I hold every build to.

  • Exceptions are designed, not discovered

    Missing data, unclear messages, API failures, no availability. I map these before building, and each one gets a defined path.

  • People step in at the right moments

    Approvals, judgement calls and anything sensitive go to a person, with the context already attached so they don’t start from zero.

  • Failures are loud

    If something breaks, someone gets told. A workflow that fails quietly is worse than no workflow, because you think it ran.

  • One source of truth

    Every system writes back to a record the team can actually see, so the automation is never a black box.

Next step

Tell me what you’re trying to automate.

Describe the workflow in your own words. What happens now, where it hurts, which tools are involved. I’ll read it and get back to you.

Tell me what you’re trying to automate