How we work
Module by module, and each one
ships something that works.
A company does not change how it works overnight. The system comes in piece by piece, leaning on what already runs, and each piece is live before the next one starts.
What gets automated and for whom lives in Solutions. This page is the other half: the order things get built in, what gets tested before a process is released, who signs what cannot be undone, and how each part is charged.
The path,
start to finish.
No stage depends on the previous one being perfect. Each one leaves something the company can use even if the project stops there.
Before starting
Survey and written rules
We walk the circuit with the people who operate it: where an order or a query comes in, who touches it, what gets decided from memory and where time is lost. The rules that live in someone head today get written down, versioned and agreed. This is the part that cannot be rushed and the one that prevents building on an assumption.
What staysYour operation in writing, with the rules agreed. It is yours even if you stop there.
Stage 1
The circuit that hurts most
One is chosen, the one with the highest return, and it is delivered working end to end. It is usually the one that eats the most hours or the one that produces the most expensive mistakes.
What staysThat circuit running whole, with a record of what happened in every case.
Stage 2
What connects around it
The systems the company already works with are integrated through their interfaces, with guarantees that a retry will not duplicate an operation. Nothing is replaced before its replacement is proven.
What staysWhat you already use, connected, and no 2 versions of the same data.
Stage 3
The modules that follow
They are added one at a time, in the order the operation asks for. As they advance, the previous tools shrink to whatever we do not cover yet.
What staysOne more module running at a time, with no useless in between state.
Ongoing
Operation and evolution
The system hangs off third party services that change without warning, and the business changes too. Monitoring, alerts, fixes and rule adjustments are part of the service, not a separate project.
What staysMonitoring, alerts and rules kept in tune for as long as the system is alive.
What gets tested
before a process is released.
Automating something that touches money with no trial period is the fastest way to lose the team that has to use it. A new process goes through 3 positions, and it leaves each one on a condition, never on a date.
Running in a process
What the system does
What your team does
When it moves on
01Shadow mode
What the system doesProposes the answer or the action and writes it down. It executes nothing.
What your team doesConfirms or corrects case by case, with the proposal in plain sight.
When it moves onWhen what it proposes stops being corrected, on real cases and with enough volume for it not to be luck.
02Pilot
What the system doesExecutes, limited to the group of customers the company picks.
What your team doesReviews what was executed and flags exceptions, which keep their reason.
When it moves onWhen that group goes a full season without an exception the system failed to hand to a person.
03Open
What the system doesExecutes for everyone, and stops only what the rule marks for a person to sign.
What your team doesResolves exceptions and adjusts the rules when the business changes.
When it moves onThere is no next one. It goes back to shadow mode when the rule changes or the process is rebuilt.
Who signs
what cannot be undone.
Some decisions no agent takes alone: issuing a credit note, publishing something on behalf of the company, sending a customer a closed price. The process prepares them whole and stops.
Stopped is not lost. The work waits with everything that was verified in plain sight, with who asked for it and who can sign it. If nobody signs, nothing happens, which is exactly what should happen.
Waiting for confirmation
Support · Quotes
- Who asks for it
- The support process, after a query that came in through WhatsApp in the middle of the night.
- What was verified first
- The person is identified and their record is the same one as always.
- Every item came from the catalogue, not from the agent memory.
- The price was set by the quantity rule, not by the model.
- Who can sign it
- Anyone on the sales team of the account.
Who does what,
and who answers.
Artificial intelligence executes and people direct. That is not a slogan: it translates into who can do what inside the system.
The agents
They interpret, look things up, draft and run actions from a closed set of tools. They never calculate money: amounts and balances come from the data or from verifiable code.
Your team
Handles the exceptions, which is where judgement pays off. Each case arrives with context and direct actions, not as a bare alert someone has to investigate.
Us
We design the processes, test them, correct them and maintain them. When something breaks there is a person on our side who answers, not a form.
Irreversible decisions
Issuing a credit note, releasing a blocked customer’s credit, publishing something in the company’s name: a person always signs off.
How it is charged,
and why the second one pays less.
The same solution, quoted twice: for the company the circuit is built with, and for the one that arrives later with a similar circuit. What has to be done changes in every part of the work, and that is where the price changes.
Scope sheet
The company the circuit is built with
The one that arrives later
Surveying the circuit
The one that builds itIt gets walked end to end with the people who operate it, with nothing similar written down before.
The one that arrives laterIt gets compared against the circuit already written, and only what this company does differently is surveyed.
The rules of the business, written down
The one that builds itThey get written from scratch: who gets credit terms, what discount applies, when something is escalated.
The one that arrives laterIt starts from the rules already agreed and adjusts what is specific, which is usually little.
The modules that already exist
The one that builds itThe ones that exist get switched on, and they sit inside the monthly subscription.
The one that arrives laterThe same ones get switched on, plus the ones the first company paid to build.
What the circuit needs and does not exist yet
The one that builds itIt gets built, quoted by stage with closed scope and price. It is the heaviest part.
The one that arrives laterIt is already built: it gets switched on, and it costs what the subscription costs.
The configuration: words, fields, stages and pricing rules
The one that builds itIt gets written in full, and corrected against the real operation until it holds.
The one that arrives laterIt is inherited, and only what differs gets changed. It is still configuration, not new code.
The processes, with what each step verifies
The one that builds itThey get designed step by step, tested on real cases and corrected.
The one that arrives laterThe ones already tested run, with this company’s own steps added on top.
The connectors with what the company already uses
The one that builds itOne gets written for every system there is to talk to.
The one that arrives laterWhoever uses the same system already has it. Whoever uses another one writes only that.
Much of a solution is configuration: vocabulary, fields, stages, pricing rules. What is code gets written once and lives behind common interfaces, so connecting another bank, another carrier or another provider means writing an adapter, not redesigning the circuit.
That is why every new solution stands on everything built before it. A company arriving second to a similar problem starts on top of what already exists, and that shows in the scope and in the price.
Modules go by subscription
The subscription covers infrastructure, maintenance, support on the same channel where you operate, and the improvements developed with other companies.
What gets built goes by stage
With closed scope and price before starting. Whatever comes up later is classified by size, and every size has a known range.
Nothing is quoted by the hour
Charging by the hour rewards taking longer and punishes the very thing that makes the system valuable: arriving with half the work already built.
Want to see how this would apply to your operation?
Tell us how your circuit works today and we will come back with a staged plan.