Agency buyers
Base44 for Agencies
OffRamp · October 29, 2026 · 8 min read
Short answer: on Base44, the agency owns the workspace and the workspace owns the app — so the client's app is only as independent as the agency's account. Agencies are a distinct buyer class: they build client apps, hand them off, and bill for them. Every one of those steps has an ownership trap on a platform where apps cannot leave. This page maps the traps and the way out.
Client handoff
The handoff problem: who owns the app when the engagement ends
Every agency engagement ends the same way: the client should walk away owning a working app. On Base44, that sentence has a catch — the app lives inside a workspace, and the workspace lives inside an account. If the agency built the app in its own workspace, the agency owns the app, its database, its users, and its subscriptions. Ownership follows the account, not the invoice. The client paid for the build; the agency holds the asset.
The usual fixes do not fix it. Building in a client-owned workspace only helps if the client actually has their own Base44 account, pays their own plan, and the agency never needs the app again — and even then, the agency's access is a permission, not a handoff, until the day it is revoked. Handing over credentials for an agency workspace is worse: the client inherits the agency's billing, the agency's other apps, and a tangle nobody can unwind. And Base44's export does not solve handoff either — it carries the code via GitHub sync, not the running app. A code export is a parts list, not a working vehicle; the database, the logins, the backend functions, and the integrations stay behind. Our export guide walks through exactly what the export contains and what it never will.
So the handoff an agency promises and the handoff Base44 allows are two different things. The promised one ends with the client owning a running app on accounts in their own name. The allowed one ends with the client depending on the agency's account forever — or accepting a code export and rebuilding the rest themselves. The gap between those two is where agency-client relationships go to die.
Billing and workspaces
Per-client workspaces and the credits bill
Agencies usually separate clients into per-client workspaces — sensible for organization, but it does not change the money mechanics. Base44 bills message and integration credits to the plan, and the plan belongs to whoever holds the account. In practice the agency pays Base44 and passes the cost through, either as a line item or folded into a retainer. That makes the agency the middleman on a meter it does not fully control.
The risk is the meter's shape. A client's app that goes viral, a runaway AI loop, or an integration that polls too often burns credits against the agency's plan — and the bill arrives at the agency before the client pays. Agencies price fixed retainers against a variable cost, which means every engagement carries an unpriced risk: the month the credits bill doubles and the client refuses the pass-through because "we agreed on a fixed fee." There is no per-client credit cap that turns the meter into a budget; the closest thing is watching the dashboard and hoping.
The honest agency playbook prices the risk in: either the client holds their own Base44 plan (and the agency bills time, not usage), or the retainer includes an explicit credits line with a stated overage rate. What does not work is pretending the meter is the client's problem while the account is the agency's — because when the bill spikes, it lands on whoever holds the plan.
The risk nobody quotes
What happens to a client app if the agency stops paying
This is the sentence agencies never put in the proposal, and it is the one that matters most: if the agency stops paying Base44, every client app in the agency's workspaces goes dark — logins fail, the database goes unreachable, backend functions stop, and each client's domain points at nothing. The client's app has no independent existence; it is a tenant in the agency's account, and tenants get evicted with the landlord. What actually stops the day you cancel walks through the full shutdown sequence.
Run through the ways this actually happens. The agency loses a big client and downsizes its plan — every other client's app feels it. The agency's card expires over a holiday weekend and nobody notices until a client's users complain. The agency closes, pivots, or gets acquired, and the new owners do not keep the Base44 bill. In every case the client discovers the same thing: their app was never theirs. They have no connection string, no database backup, no server to log into — just a code export, if anyone remembered to make one, and a rebuild project where their live app used to be.
For the client, this is the single biggest argument against agency-built Base44 apps — and for the agency, it is the single biggest liability hiding in the portfolio. One unpaid bill, and the agency is not just embarrassed: it is in breach with every client whose app went down. The fix is not a bigger retainer. The fix is making sure no client app depends on the agency's account in the first place.
The agency playbook
The agency-safe way to build client apps
There are two honest ways to ship client work without the ownership trap. The first is to build on client-owned infrastructure from day one: the client holds their own Supabase, Vercel, and GitHub accounts, the agency builds into them, and the handoff is credentials, not a migration. The agency keeps its builder speed; the client keeps the asset. SaaS founders face the same fork at a different scale — can you build a SaaS on Base44 is yes for the MVP, with real multi-tenant isolation as the breaking point. The second — for apps already running on Base44 — is to migrate at handoff: move the client app onto the client's own infrastructure accounts, verify it live there, and only then retire the agency's copy.
That is what OffRamp does for agency engagements: it migrates a Base44 app onto Supabase, Vercel, and GitHub accounts in the client's name, so the database, the logins, and the integrations move with the code instead of staying behind on the agency's plan. Once the migrated app is live and verified, the agency hands over credentials and walks away with a clean break — or keeps a maintenance retainer on infrastructure it no longer has to defend. Ownership without portability is just a lease, and for agency clients, the lease should be in the client's name from the start.
Pitch it to clients as what it is: risk removal. The agency that hands over a client app on client-owned infrastructure is selling something no Base44-native handoff can match — an app the client actually owns, that survives the agency's own billing, and that no platform can repossess. That is a closer, not a cost.
FAQ
Questions, answered honestly
Can I transfer a Base44 app to a client?
A Base44 app lives inside a workspace, so a true handoff means moving the app out of the agency's account — and Base44's export carries the code, not the running app. The clean transfer is a migration: the app is rebuilt on the client's own infrastructure accounts, verified live there, and only then is the agency's copy retired.
Who owns a client app built by an agency on Base44?
Whoever owns the workspace owns the app. If the agency built the app in its own workspace, the agency owns the app, its database, and its subscriptions — regardless of who paid for the build. Ownership follows the account, not the invoice, which is why handoff has to be a deliberate migration, not a handshake.
What happens to a client app if the agency stops paying Base44?
The same thing that happens when anyone stops paying: the app stops working. Logins fail, the database goes dark, backend functions stop, and the domain points at nothing — for every app in the unpaid workspace, including the client's. The client has no independent copy of the running app to fall back on.
How do agencies bill clients for Base44 usage?
Message and integration credits are billed to the workspace plan, so the agency pays Base44 and passes the cost through — usually as a line item or folded into a retainer. The risk is the meter: a runaway AI loop or a viral client app burns credits against the agency's plan, and the bill arrives before the client pays.
Can my client access their own app's database on Base44?
Only through the agency's Base44 account. There is no connection string to hand over — Base44's database cannot be reached from outside its own platform. Until the app is migrated onto infrastructure the client owns, the client sees their data only through the agency's login. Our database page explains why there is no back door.
What is the clean way to hand off a Base44 app to a client?
Migrate it onto the client's own accounts first: Supabase, Vercel, and GitHub in the client's name, with the app verified live there. Then the client owns the running app, its database, and its hosting bill — and the agency can hand over credentials and walk away with a clean break, or keep a maintenance retainer on infrastructure it no longer has to defend.
Shipping client apps on Base44?
Hand each client an app they actually own: migrate the client app off Base44 onto Supabase, Vercel, and GitHub accounts in the client's name. Connect the Base44 account from the OffRamp home page. The free analysis takes about a minute, and your fixed quote comes with it.
Start your free analysis