Yaakov.AIFree audit
HOW I WORK · 5 MIN READ

Who Owns the Automation You Paid For? Here's My Answer

BY YAAKOV T. · October 8, 2026
TL;DR

Every automation I build lives in your accounts, under your credentials, with documentation you can hand to any developer. You don't rent access from me. The day the build is done, you own it completely.

The question doesn't come up until it matters, and by then it's usually too late. You've paid someone to automate your order reconciliation or your lead routing, the thing runs great for eight months, and then the relationship ends. Suddenly you're staring at a workflow you can't touch, in an account you don't control, built by someone who is no longer picking up the phone.

Ownership of the automation you paid for isn't a legal technicality. It's a practical question about who holds the credentials, who can modify the logic, and who the system calls home to at 2 a.m. when something breaks. I learned that before I sold automations to anyone, because I built them first for myself.

I built Yala Vanity's backend before I understood what ownership meant

When I first wired up the supplier feeds for Yala Vanity, I was doing everything in whatever tools were convenient. Six supplier feeds, three hours of morning reconciliation, freight quotes that took four days and a lot of back-and-forth before I automated them down to minutes. The systems worked.

But I made a version of the same mistake every operator makes: some of those early builds lived in places that were fragile. A paid plan I'd forgotten to track. A credential stored in one spot but not documented anywhere. The automation ran, but I wasn't truly the owner. I was the person who remembered how it worked.

That's a problem when you're the only one running the business. It's a much bigger problem when you've paid someone else to build the system and they're the person who remembers how it works.

The agency model creates a dependency that's good for agencies

Here's how the standard agency build works. They spin up a Make or n8n instance on their own infrastructure. The API keys are stored in their accounts. The documentation, if it exists at all, is internal. You see a dashboard, maybe a Slack message when something runs. But you don't hold the keys.

That structure isn't accidental. A system you can't access without the agency is a system that generates retainer revenue. They're not necessarily being malicious. It's just that the incentives point toward dependency.

I'm not an agency. I'm an operator who automates businesses, including my own. The pricing page has the specifics, but the short version is: fixed price per build, no monthly retainer, no ongoing fee to keep your system alive.

What real ownership looks like in a delivered build

Every build I deliver follows the same structure. The workflow files live in your Make or n8n account. The API keys are generated in your name, stored in your credential vault. The Supabase project, if the build uses one, is under your email. The Twilio number, the webhook endpoint, the storage bucket: all yours.

  • You hold every API credential. Nothing is routed through my accounts after delivery.
  • The documentation is written for a developer you hire in the future, not just for me.
  • I do a live walkthrough so you understand the logic, not just the output.
  • I have no admin access after the project closes unless you explicitly invite me back for a new scope.

That last point matters. I can't reach into your system and flip a switch if you stop responding to my emails. That's a feature, not a gap in service.

The honest tradeoff: you carry more responsibility

Owning the system means you're responsible for it. If a third-party API changes its schema and breaks a step in the workflow, that lands on you to notice and fix, or to hire someone to fix it. I'm not on retainer watching your dashboards. That's the tradeoff, and I'd rather name it plainly than hide it.

"A system you own but don't understand is almost as fragile as a system you don't own at all."
Yaakov T.

That's why the walkthrough isn't optional. By the time I hand over a build, you should be able to explain to a developer what each step does. Not how to recode it from scratch, but what it does and where it lives. That's enough to maintain it, extend it, or hand it off.

The first automation worth building post goes into the specific order of operations I recommend. The principle carries through: start with the system that costs you the most time, build it so you own it, and document it before you call it done.

The one exception: the Ongoing Partner arrangement

There is one context where I have ongoing involvement, and it's worth being precise about what it is and isn't. Some operators want a standing relationship where I'm available to extend their systems as the business grows, prioritized and without starting a new scoping conversation each time. That's the Ongoing Partner arrangement.

It's not a retainer in the sense of a monthly fee that keeps your current systems running. The systems you've already paid for run on your infrastructure without me. The arrangement is about future builds and extensions, scoped and priced as projects, with faster turnaround because the context is already established.

The automations page and the pricing page both have the specifics if you want to compare. But the ownership structure doesn't change: what I build for you is yours.

What to check if you're not sure you own what you paid for

Pull up the workflow tool, whether that's Make, n8n, Zapier, or something else. Check which email address owns the account. Open the connections or credentials panel and look at who authorized each API integration. If the answer is a vendor's email address, you're renting.

  • Account email: should be yours, not a vendor's agency address.
  • API credentials: should be authorized under your app registrations, not someone else's.
  • Webhook URLs: if they point to a domain you don't control, a change on their end breaks your flow.
  • Documentation: if you don't have it, you effectively don't own the system even if the account is technically yours.

If the audit reveals you're renting, the fix is a rebuild under your credentials. That's a clean fixed-price project. The free audit on the book page is where that conversation starts: you describe the existing setup, I tell you plainly what's recoverable and what needs to be rebuilt.


Ownership isn't a buzzword in my proposals. It's the specific answer to: whose account holds this, whose name is on the API key, and who can read the documentation when I'm not available. Every build I do has a clear answer to all three. That's what being an operator instead of an agency actually means in practice.

§ FAQ

Frequently asked questions

who owns the automation after yaakov builds it

You do. Every workflow, every credential, every API key lives in your accounts from day one. I don't host your automation on shared infrastructure or hold admin access after delivery. You get the build, the documentation, and a walkthrough. I have no ongoing lever to pull that could break or hold your system.

do I have to keep paying a monthly fee to keep the automation running

No. I charge a fixed price per build, not a monthly retainer. You pay once, you own the system. The only recurring costs are whatever the underlying tools charge you directly, things like n8n cloud, Make, or Supabase, and those are your accounts, your invoices, nothing routed through me.

what happens if I want to change something after the build is done

The documentation I hand over is written so a competent developer you hire later can pick up where I left off. If you want me to extend the system, I quote that as a new fixed-price project. There's no retainer that locks you into coming back to me.

can I see what the automation actually does before I pay

Yes. The free audit on the book page produces a plain-English scope before any money changes hands. You'll see exactly what gets automated, which tools it touches, and what the build does and doesn't cover. No mystery, no bait-and-switch scope.

what if I already have automations built by an agency and I'm not sure I own them

Check which accounts hold the API keys, the workflow files, and the hosting. If those are the agency's accounts, you don't own the automation, you're renting it. The fix is a rebuild under your credentials. That's a clean fixed-price project, and it's something I scope out during the audit.

§ NEXT STEP

Want your business audited like this?

Twenty minutes on the phone. No pitch. You leave with a ranked list of what to automate first in your business — whether or not you hire me.

Free automation audit — 20 min