← All expertise

05

Automation and AI

The repetitive work that runs itself, with a person making the call

Automating is easy while everything works. The real work is deciding what happens at step three of seven when step four fails: roll back, retry, or call someone?

How an automation is built
  1. The manual workWe watch and time what gets redone every day, and what it costs
  2. DecompositionSmall steps, each with its own way of being undone
  3. Dry runOn real data but without effects, until the behaviour is clear
  4. ApprovalWhere the action is public or irreversible, a person decides
  5. QueuedRetries, limits and a trail of every attempt
  6. MeasureHow many hours came back: if it isn't measured, it isn't an automation

Every step knows how to undo itself

An automated work cycle is a distributed transaction: every step has its own way of being undone, a retry ceiling and saved state. If it falls over halfway, the system knows where it was and what to undo — it doesn't start again hoping nobody notices.

Every step is written to be repeatable: sooner or later it will actually be repeated.

A real queue, not a reminder

Jobs live in a queue with exclusive claims, so two workers never do the same thing twice. The queue is drained on a schedule and right after an insert, so nothing waits for the next tick without reason.

AI where it adds, people where it counts

Language models are useful for understanding and proposing: draft replies, classification, extracting data from documents and invoices. But while an action is public or irreversible, the proposal goes through an approval — in the app or as a two-button message — and stays on the record.

The value is not "AI does everything": it is removing the mechanical preparation and leaving the decision to a person, with the context already laid out.

What we automate first

Not what annoys people most: what costs most. They are two different things, and the most hated task is almost never the dearest. You measure first — minutes per occurrence, occurrences per day, people involved, errors in the last three months — and start from the top line.

A good candidate has three properties: clear rules, high volume, low ambiguity. If one is missing, the automation costs more than it returns, and it is better said before starting.

Where AI helps and where it doesn't

It helps where understanding is needed: reading an invoice in a format never seen, classifying a free-text request, summarising a long case, drafting a reply. Tasks where an occasional error is tolerable because someone checks afterwards.

It doesn't help where guaranteed exactness is required: calculating a total, deciding a discount, applying a contractual rule. Those stay written, deterministic, verifiable rules — and the fact that today you can ask a model anything doesn't mean you should.

The practical line we use is irreversibility: if the action sends something outside the company or deletes, it needs a human yes, and it stays on record who gave it and when.

What must be decided before, not after

Which data may go to an external service and which may not: customer records, health data, documents under confidentiality. A decision to take once, write down and make known — not one to leave to the habits of whoever uses the tool.

Who answers for what goes out: accountability stays with whoever signs, always. No supplier takes it, and anyone claiming otherwise hasn't read the contract they are handing you.

How it is measured: hours saved, errors avoided, response times. If after three months you can't say whether it helped, you don't have a project, you have a subscription.

What we build automations with

Widespread tools and state saved somewhere: the two things that separate an automation that lasts from one rebuilt at every change.

  • Orchestration

    • n8n
    • PostgreSQL queues
    • cron
    • steps with compensation

    Every cycle is split into steps with their own way of being undone and persistent state. If it falls over halfway the system knows where it was and what to undo, instead of starting again hoping nobody notices.

  • Documents

    • OCR
    • PDF extraction
    • validation against totals
    • archiving

    Extraction proposes, automatic checking decides: if the total doesn't match the sum of the lines, it doesn't pass. A person doesn't need to verify everything — the system needs to know when it isn't sure.

  • AI

    • language model APIs
    • versioned prompts
    • context from your documents
    • record of proposals

    The model works on your real data, not generic examples, and every proposal stays traced. Prompts are versioned like code: when behaviour changes, you know what changed.

  • Human control

    • in-app approvals
    • two-button messages
    • Telegram or email notifications
    • record of who approved

    While the action is public or irreversible, the proposal goes through a person. Approving must cost two seconds, otherwise it becomes an obstacle and somebody will find a way around it.

Portfolio

What we did on this, project by project.

Orbitas

Automated customer environment creation and self-healing

  • The customer creation cycle split into traced steps with retries and a final smoke test, instead of one monolithic script.
  • Periodic comparison between real and desired state, with automatic reaction when something drifts.
  • Multi-level automatic service repair, keeping a trail of what was attempted and when.
  • n8n
  • PostgreSQL
  • bash
  • Consul

BigFishIta

Content orchestrator and agents

  • A PostgreSQL job queue with exclusive claims and retries, drained every two minutes and right after each insert.
  • Agents that prepare the work — analysis, drafts, proposals — and put it up for approval: nothing public goes out without an explicit yes.
  • Operational notifications on Telegram with AI-assisted quick actions, and periodic comment checks as a safety net.
  • n8n
  • LLM APIs
  • PostgreSQL
  • Telegram
  • cron

Need this?

Tell us the problem and we'll tell you how we would tackle it — and if it isn't worth doing, we'll tell you that too.

Let's talk