nfstudio.

I build the AI that does your boring work.

You watch it run before you buy. The prices are on the wall. And if it does not do what we agreed in writing, you get your money back. That is the whole pitch.

Book the free 20-min call Watch a demo first

The call is free. The Diagnostic it leads to costs 1,750 EUR — and every euro of it comes off your first build. A build refund never returns the Diagnostic fee — its own guarantee does that: find nothing worth 5 hours a week, and you don't pay. The roadmap stays yours either way.

so if you go ahead, it costs you nothing

We check we're a fit first — no obligation · em português, se preferires

A simulation on fictional data: jobs arrive and move from received to working to done — an invoice extracted, a proposal drafted, an inbox message triaged — each landing in the log with its runtime.

Simulation: the work, ticking over fictional data

Sound familiar?

Five miseries.

Watch each one die — one even makes you money.

"We rewrite the same quotes and proposals over and over."

Paste a rough brief — a few messy lines about the job. The agent turns it into a formatted scope and a priced quote, in your own template, in seconds.

I use this one myself, every week, for nfstudio's own briefs. If you like what it does, yours is built the same way.

The big one

The quoting brain lives below.

Watch the whole agentic system play out below — brief in, priced quote out.

"Half our bookings come in by WhatsApp, and someone has to guess what they meant."

A booking request lands — "Friday morning" — but two Friday slots are open. Instead of guessing and booking the wrong one, the agent asks a single question, waits for the answer, then confirms the slot the client actually wanted.

It asks before it acts. One clear question beats a calendar full of wrong-time bookings and the calls to unpick them.

In this simulation

Answering a booking, by hand
hours — when someone is free
With the agent
seconds — and it asks if unsure

A simulation on fictional data: a booking request arrives by WhatsApp asking to book Friday morning. The system checks the calendar and finds two Friday-morning slots open, so the request is genuinely ambiguous. Instead of guessing and risking the wrong time, it asks one structured question: Friday at 09:00 or 11:00? The human picks 09:00 and the booking lands — Friday 09:00, João Marques, confirmed — with a reply sent back. End state: one booking made from one calendar check and one question, no wrong guess.

Demo: the booking that asks first Simple — from 4,500 EUR simulation · fictional data

"Everyone asks the same three questions and nobody can find the file."

An agent that has read your manuals, your contracts, your price lists — and answers in plain language in seconds, with the source file attached.

What follows is a simulation on fictional data — the real version reads your own manuals and price lists, not ours.

I made this one after watching a client's team ask “where's the updated price list?” four times in one afternoon.

— the person who builds these

In this simulation

Finding the answer, today
15–40 min
With the agent
8 seconds

A simulation on fictional data: two questions arrive over WhatsApp — how many years of warranty the X200 carries, and the current price for the X200 kit. The system searches the company's own files and matches three. The warranty answer comes straight from the manual, two years parts and labour, with the source file named. For the price, two of the matches are price lists — the system does not guess: it says so, names both, and answers from the newer one, 340 EUR. End state: two questions, two answers, each with its source file attached.

Demo: the assistant that cites its source Simple — from 4,500 EUR simulation · fictional data

"We send the quote and then nobody follows up on it."

Quotes that went quiet queue up for a polite nudge, each marked with how long it has been waiting. The follow-ups go out one per client — and if the connection drops mid-run, nothing is lost and nothing sends twice; the queue waits and finishes the job once it is back.

Every quote gets exactly one follow-up: never forgotten, never doubled. The chasing you keep meaning to do, handled without you.

In this simulation

Chasing one quote, by hand
~5 min, when you remember
With the chaser
seconds each, none forgotten

A simulation on fictional data: the system reads your invoicing tool and finds the quotes that got no reply, each tagged with how long it has been waiting. It sends the first nudge, then the connection drops mid-run — nothing errors and nothing sends, and the queue simply keeps counting as more unanswered quotes pile on. When the connection returns the whole queue drains: every client gets exactly one follow-up, never two. End state: five quotes nudged once each, the queue empty, nothing lost.

Demo: the quote chaser Simple — from 4,500 EUR simulation · fictional data

"A lead writes in on a Saturday and we answer on Tuesday — if nobody forgets."

A lead fills in your form at 23:14 on a Saturday. It looks the company up, checks it is not already in your CRM, drafts a reply that reads like you wrote it, and pencils a call slot in your calendar — then waits for your yes before anything goes out.

Whoever answers first usually gets the meeting. The boring lookup runs on its own; the message to a real prospect is still your call, one tap away.

In this simulation

Answering a lead, today
~2 days
With the responder
~40 seconds

A simulation on fictional data: a lead fills in the contact form at 23:14 on a Saturday night. The system looks the company up, confirms it is not already in the CRM, and scores it a strong fit. It drafts a short, personal reply — no template smell — and pencils a call slot in the calendar, then stops and asks the owner to approve before anything is sent. The owner approves; the reply goes out and the Monday 10:00 slot is held. End state: one lead answered in about forty seconds — a reply sent and a call slot held — where the average company takes about two days to reply, and most never do.

Demo: the lead that gets answered first Simple — from 4,500 EUR simulation · fictional data

Why not just a chatbot?

Fair question — a chat assistant is twenty euros a month and it is genuinely useful. But it lives in a text box: ask it to chase your overdue invoices and it writes you a good plan for chasing them. An agent has hands — it reads your invoicing, drafts the reminders, and, once you say go, sends them.

A chat

A simulation on fictional data: the same request goes to a plain chat assistant — chase the invoices that are overdue. It answers well, with a sensible playbook: a reminder at seven days overdue, a firmer one at fourteen, a payment-plan offer if they go quiet. Good advice — and only advice. A chat has no way into your invoicing, so the tally of what it actually sent is nothing. It tells you how; it cannot do it.

Prompt: a plain chat simulation · fictional data

An agent

A simulation on fictional data: the same request goes to an agent — chase the invoices that are overdue. It lays out a short plan — find the overdue invoices, draft the reminders, send them — and works it. It reads the invoicing system and finds three invoices overdue, worth 4,200 EUR, drafts a reminder for each, and pauses for one sign-off before anything leaves. On approval it sends all three. End state: the plan done and three reminders sent — the same request the chat could only answer, actually carried out.

Prompt: an agent simulation · fictional data

The chat tells you how. An agent does it.

Several agents, one job

When one workflow isn't enough.

A simple build runs a fixed line of steps. This is the tier above — several agents on one job, working in a loop instead of a straight line. It costs more because it exercises judgment, not because it is just longer.

  1. Assess

    Reads the job and works out what it actually needs.

  2. Execute

    Does the work — the searching, the drafting, the numbers.

  3. Review

    Catches the others' mistakes and sends the work back when it does not hold up — then holds anything consequential until you sign it off.

A simulation on fictional data: a rough one-line brief arrives — a booking system with SMS reminders for three clinics. The system lays out a real plan — read the brief, find comparable jobs, price every line, review the quote — and works it in a loop. Assess reads the brief; Execute searches past jobs (three matched, at 6,500, 5,800 and 7,200 EUR), applies the house margin, and prices the lines it is sure of — booking system 4,200, SMS reminders 1,800. Then Review catches a line that matches no past job — syncing the current calendar — and sends the pricing step back down: that plan item re-opens, the machine asks one question (quote it in, or price it separately), and on the answer prices the line at 900 and re-completes the step. Review passes and a 6,900 EUR quote lands, ready in your own template. End state: the whole plan done, one step visibly re-opened and recovered, and a priced quote produced.

Demo: the quoting brain Agentic — from 15,000 EUR simulation · fictional data

Agentic — from 15,000 EUR

What that buys: a system that has to exercise judgment, not just follow steps — and it starts with a paid pilot before the full build is committed.

Before you commit to the build

The big build starts as a paid pilot.

A demo can only promise so much. So the agentic build doesn't open with the build — it opens with a paid pilot that has to earn its keep. The bar gets set, in writing, before the pilot runs.

  1. Shadow mode

    It runs beside you on the real work — reading everything, sending nothing. You watch what it would have done, live, with none of it actually going out.

  2. The agreement bar

    Before the pilot starts, we agree in writing how often it has to match you before it earns the job. Set up front, not argued after the fact.

  3. Go, or no-go

    Clears the bar, I build the full system. Doesn't, you're not committed to it — you decide with the numbers in front of you, not on a pitch.

You don't commit to the build on faith. You commit once the pilot has earned it.

Do the math

You're already paying for it.

Nobody sends you an invoice for the boring work — it just quietly eats hours. So here is one task, with the hours priced out. On the low side.

5

hours / week

spent retyping supplier invoices by hand

≈4,800EUR

a year

what those hours cost the business

from4,500EUR

once

a system that does that work for you

Five hours a week, about 48 weeks a year, at a conservative 20 EUR for each hour of that time — roughly 4,800 EUR a year, every year. The system that does it starts at 4,500 EUR, one time.

It pays for itself inside the first year. After that, it just keeps handing the hours back.

and that's ONE task — the Diagnostic usually finds four or five

No "price on request"

The prices, on the wall.

Which one do I need? Most first builds are the simple kind — the Diagnostic tells you which one yours is.

Every competitor hides their prices behind a "free strategy call". I put mine here instead — if the numbers do not work for you, I would rather you knew in thirty seconds than after three meetings.

1,750EUR

Start here

The Diagnostic

the whole 1,750 comes off your first build

I spend real time inside how your company works, then hand you a ranked list of what to automate — with what each one costs and what it saves. Not a free "diagnóstico" that is really a sales call: it is paid, fixed-scope, and you keep the written roadmap whether or not you build. Go ahead, and every euro comes off the bill.

  • Credit it against a build, or take the roadmap and walk — both real
  • If it can't find at least 5 hours a week of recoverable time, you don't pay — decided at the wrap
  • Remote shadowing — no consultants camping in your office
  • A roadmap ranked by payback, not by buzzwords
  • Draft acceptance criteria in writing, one per automation
  • Gated by a free 20–30 minute call
  • Split it if you like — half at kickoff, half at the wrap

Book the diagnostic

1,200EUR

Standalone

The Workshop

A half-day session on your real process. Standalone — and it doubles as paid reconnaissance: I'm in the room, and the automation opportunities introduce themselves.

  • Half a day, remote or on-site
  • Your team, your real workflow
  • Doubles as paid reconnaissance

Ask about a workshop

from4,500EUR

Then, if it makes sense

A Build — simple workflow

Guaranteed in writing

One fixed, multi-step workflow, quoted from the Diagnostic. It does the job to the letter of what we agreed — or the build fee comes back.

Runs the steps, in order, exactly as we specced them.
  • Typical range 5,000–7,000 EUR — a fixed price, not billed hours
  • Up to 3–4 connected workflows, built production-ready
  • Wired into your real tools — Moloni, PHC, Primavera, your inbox — through their own APIs
  • A human review gate on anything that sends — nothing goes out on its own
  • Error handling, logging and a testing log you can read
  • A live handover, written docs per workflow and a walkthrough video
  • Roughly 30 days of free support after launch, then Care if you want it
  • You own the code and the data — cancel Care and it keeps running

Book a call to get quoted

from15,000EUR

The bigger build

A Build — agentic system

Guaranteed in writing

A system that has to exercise judgment, not just follow steps. Priced deliberately above the simple tier — and it starts with a paid pilot before the full build is committed.

Decides what to do, handles the odd cases, and checks its own work before it acts.
  • Typical range 18,000–30,000 EUR
  • Everything in the simple build, plus a paid pilot before the full commit
  • Shadow mode — it runs beside you on real work, sending nothing
  • An agreement bar set in writing up front, before the pilot starts
  • A go/no-go gate — the full build only if it clears the bar
  • Backed by the same binary guarantee

Book a call to get quoted

Keep it running

Care — the monthly retainer.

Each tier covers one system — the automation it is attached to; running more than one is quoted at proposal time.

  1. 250EUR / month

    Care Lite

    Monitoring and minor fixes. The system is watched; small breakages get fixed as they surface. The easy recurring yes.

  2. 750EUR / month

    Care Standard

    Everything in Lite, plus up to 4 hours a month of build and optimization time — for the client whose process keeps moving, so the system keeps moving with it.

  3. 1,800EUR / month

    Care Pro

    Everything in Standard, plus priority response times and hands-on tuning when something drifts, and up to 10 hours a month for systems that genuinely need it.

What the monthly price does not include

Care covers my work — monitoring, fixes, build time. It does not cover the AI usage itself, the tokens your automations spend. No hidden fees means saying that out loud:

Default — By default, your own accounts. Automations run on AI accounts in your name — I set them up, you add a card, the provider bills you directly. Cancel Care and the automation keeps running. Figure roughly 10–50 EUR a month for a simple workflow, 30–150 EUR for an agentic system. The Diagnostic estimates this before you commit a cent.

Or hosted — Hosted by me, if you'd rather not manage accounts. I run it on my own EU infrastructure (Hetzner) — from 50 EUR a month per system, plus AI usage passed through at cost and itemized. No markup on the tokens.

The guarantee

It works, or you don't pay.

MONEY
BACK

no fine print

The guarantee is binary on purpose. Before I build, we agree in writing exactly what "working" means — a number, not a feeling. If the system does not clear that bar over a 14-day window on your real data, I refund the build fee. No partial credit, no store vouchers, no debate.

  • Refunds the build fee — the Diagnostic fee answers to its own guarantee, not this one (either way the roadmap is yours).
  • Measured against the metric we agreed, counted from logs, not judged by taste.
  • I guarantee the system does what we specced — not that your revenue moves. That depends on adoption, not code.
  • I can sign this because I don't quote anything I haven't diagnosed first.

— nfstudio

Who you're dealing with

I build these myself.

Software engineer, Vila do Conde. Years building web systems for companies, and the last few building AI agents — including for my own work, every day. No sales team, no account managers, no juniors learning on your budget.

The person you talk to on the first call is the person who writes the code and signs the guarantee above. And if your problem is not a good fit for automation, I will tell you on that call — a wasted build costs me a refund, so I am careful about what I say yes to.

  • Builds every system personally
  • Answers in PT or EN
  • Remote — no office theatre
  • Says "no" when it is not a fit

You've read the guarantee and met who signs it. There's nothing left to decide on faith.

Book the call

Before you ask

The questions I always get.

What if it doesn't work?
We agree the acceptance criteria in writing before I build — a measurable bar, met or not met. I measure it over a 14-day window on your real data. If it does not clear the bar, I refund the build fee. No partial credit, no debate. The Diagnostic fee sits outside this guarantee — it has its own: if the Diagnostic cannot find you at least 5 hours a week of recoverable time, you do not pay it. The roadmap is yours either way.
Whose servers is this on? Where does my data go?
By default your automations run on accounts in your name, so your data never leaves your control. If you would rather I host, it runs on my own EU infrastructure (Hetzner, in Germany) — GDPR-friendly, and your data stays in the EU. Either way, nothing goes anywhere we did not agree.
Do I need technical staff to use this?
No — that's the whole point. I build it, set it up on your accounts, and hand it over running. Care covers the monitoring and fixes, so you do not need someone in-house to babysit it.
Does it run on its own, without me watching it?
The boring, reversible parts run unattended — reading, sorting, drafting, filing — because that is the whole point. But anything that leaves the building — a message sent, a price quoted, something published — stops and asks you first. That is a deliberate choice, not a limitation: you never want to babysit the reversible work, and you never want to be cut out of the consequential kind. The vendors who promised fully hands-off autonomy are the ones whose customers quietly turned it back off.
Who decides what needs my sign-off — and can I move that line?
You do. When it is built, we set together exactly which actions stop and wait for you — usually anything that reaches a customer or moves money — and which ones just run. That line is not welded shut: as you learn to trust it you can let more through, or tighten it back up if something ever feels off. It is your process; the machine asks where you tell it to ask.
What does an automation actually look like?
Watch the demos above — each one is a real agent killing a real misery on dummy data. Yours would be built the same way, scoped to your process from the Diagnostic.
How long does it take?
The Diagnostic runs over roughly 1–2 weeks and asks for about 4–6 hours of your team's time in total — a kickoff, a couple of process interviews, and the wrap presentation. The rest of the analysis happens on my own time between sessions, so it fits around a normal working week. The build that follows is scoped and quoted from the Diagnostic, so you get a real timeline before you commit to it.
Does it work with Moloni, PHC, Primavera or InvoiceXpress?
Usually, yes — those are the tools most of you already run, and they connect through their APIs or their exports. That is the normal case, not a special project. What I will not do is promise it blind: the Diagnostic confirms exactly what each system can hand over before anyone quotes a build on top of it.
What if my process changes after the build?
That is what Care is for. Small shifts — a tweak, a new field, a rule that moved — are its bread and butter, and Care Standard carries up to 4 hours a month of build time for exactly that. A bigger reshape is a new scoped project, quoted honestly — not smuggled in as a 'fix'.
Can I start smaller?
Yes — the Workshop. A half-day AI-literacy session for your team on your real process, standalone at 1,200 EUR. No Diagnostic, no strings — just your people getting fluent enough to see what is worth automating. It doubles as a cheap look at how I work before you commit to anything bigger.

The next step

Book the free call.

Twenty to thirty minutes, no charge — a call, not a "discovery call". We check it's a fit, confirm there's real repetitive work worth shadowing, and you leave knowing exactly what you'd be getting. If there's nothing here worth automating, I'll tell you on the call and we both save the money.

The call is with the person who builds these — not a salesperson, not a hand-off.

How it usually goes

  1. Free call
  2. Diagnostic
  3. Build
  4. Care

One reply, from a human. No sequence, no newsletter.

nfstudio — Vila do Conde, est. 2026

EN PT

Free call. No obligation. Book the call