How to hand a client the app you built for them with AI
You're a freelancer or consultant, and the tool you built with a coding agent is done. How the client gets in, who looks after access, what they can see about it, and what to give them when the work ends.
Freelancers and consultants are building more of their deliverables with coding agents. A bookkeeper builds a client an expense review tool. An operations consultant builds an intake tracker for a client's support team. A small agency builds a content calendar the client's marketing team will use every week.
The building is the fast part now. Handing it over is where the questions start. Where does it run? How does the client's team sign in? Who adds the next person when someone joins? What does the client see about what the tool stores? And what do they keep when the engagement ends?
This article goes through those questions. We make Spryloom, and the second half describes how it handles them, so read that part knowing who wrote it. The usual options are first, and each is the right answer for some engagements.
What a handover needs
Whatever you use, a client handover has to cover five things:
- The client's people can get in, with their own addresses, and nobody else can.
- The client can manage who's in without emailing you every time someone joins or leaves.
- The client can see what it is: what it stores and who made it.
- It keeps running when you're on your next project.
- There is a way out: the code and the data, if they leave you or the platform.
Option 1: hand over the code
Give the client the repository and let their IT team run it. For a client with engineers and a hosting setup of their own, this is the cleanest ending. You're done when you push the last commit.
It assumes the client has someone who can deploy it, set up a database, and put a login in front. Many small clients don't, and that's often why they hired you.
Option 2: host it on your own account
Put it on a general host like Vercel, Render or Railway under your account, and have your agent add sign-in. It's familiar, and you stay in control.
The cost is that the sign-in code, the database setup and the hosting bill are all yours to keep correct, for as long as the client uses the tool. Each client adds another set. Moving it to the client's account later is a migration.
Option 3: the client's own platform
If the client already has an internal tools platform or a no-code database their team lives in, building there means it fits their existing logins and permissions. The trade-off is that you build in their tool, not in the code your agent writes.
Option 4: publish it on Spryloom and make the client an admin
Spryloom runs apps your agent built behind sign-in. The app contains no login code. Spryloom checks who each visitor is before anything reaches the app, and tells the app their address and role.
Let the client in
Say Jordan runs a two-person consultancy and has built an onboarding tracker for a client's HR team. In spryloom.yaml, the manifest the agent writes, Jordan sets who can use it and names the client's HR lead as an admin:
app:
name: Onboarding tracker
description: Tracks each new hire's first-month tasks, for the HR team.
runtime:
frontend: react
backend: node
start: node server.js
access:
visibility: invited
admins: [megan@yourclient.com]
data:
postgres: true
tables: [hires, tasks]
Then Jordan publishes from the app's folder, with npx -y spryloom publish, or by asking the agent. Invitations can go to anyone with an email address, so the client doesn't need to be in your company or your workspace:
spry invite onboarding-tracker --email megan@yourclient.com
What the client sees
Megan gets an email from Spryloom naming the app, who invited her, and the description above, in your words. Write that sentence for the client: it's how they decide whether to trust a link from a contractor.
Its Open Onboarding tracker button and one press of Continue sign her in. The button works once, for seven days; after that, she signs in with an emailed link. There is no password, and no account to create.
Who looks after access
Because Megan is listed in access.admins, the label page names her as an administrator, and she opens the app whether or not she was invited. What she can't do is manage who's in. That happens in the workspace the app lives in, which is yours, and Megan signs in to Spryloom in her own.
spry invitespry uninvite, effective on their next clickInside the app, Megan arrives with the admin role and her team with user, so the agent can reserve delete buttons or settings for admins. Being let into this app grants nothing on any other app, including your other clients' tools in the same workspace.
The client can see what it holds
Every app has a label page at /~label on its address, written by Spryloom, not by your app, and behind the same sign-in. It is generated from what was actually built, so the tables listed are the ones you declared and the services are the ones it can really reach. By default, that's none. This is roughly what Megan sees:
Onboarding tracker
Tracks each new hire's first-month tasks, for the HR team.
What it holds- Storeshires, tasks
- File uploadsNone
- Can reachNothing outside Spryloom
- Shared withPeople who were invited
- Administratorsjordan@jordanconsulting.com, megan@yourclient.com
- Made byjordan@jordanconsulting.com
- Sign-inA link sent to your work email
Point the client's IT or compliance person here. It answers "what is this thing" without a call.
It keeps running
The app runs on its own small machine with its own Postgres database. Nobody else's app can reach it. You can see whether it's running with spry apps, read its output with spry logs onboarding-tracker, and go back a version with spry rollback onboarding-tracker. If the client needs a change, you make it with your agent and publish again: same address, same data, same people.
If it needs a key for an outside service, such as a Stripe or HubSpot key the client owns, it's set with spry secrets onboarding-tracker set NAME=value. Nobody can read it back, including you. The client doesn't paste it into a chat or the repository.
When the engagement ends
Give the client the repository. The app has no Spryloom code in it beyond reading two headers that say who is signed in, and spryloom.yaml says what it needs. Their engineers, or the next contractor, can see the whole thing.
Then give them a record of the app itself, and park it if they won't need it for a while:
# manifest, who it's shared with, versions, audit history spry export onboarding-tracker > onboarding-tracker-spryloom-export.json # stop serving it, keep its data spry archive onboarding-tracker # bring it back spry restore onboarding-tracker
The export doesn't include the rows in the app's database, because Spryloom doesn't read those. Have the app offer its own export, such as a CSV download for admins, and ask your agent for it while you build. If the tool is a page that saves data instead of an app, spry data export <page> saves every record as JSON and CSV.
What it doesn't do
- Ownership doesn't move between workspaces. The app lives in the workspace of whoever published it. You can make the client an admin, but you can't transfer the app to their own Spryloom workspace. If they want it in theirs, someone on their side publishes it there from the repository, and the data is moved by the app's own export.
- It doesn't bill your client. There is no invoicing or pass-through billing. Charge for hosting the way you charge for everything else.
- It's for people you know. Everyone signs in by email link. It isn't a public site or a product for the client's customers.
- There are limits. A workspace holds 10 apps, and each app can have 25 invited people. A consultant with many clients will reach the first one. An archived app still counts, so delete finished tools once the client has what they need. Pages don't count.
- No file uploads. Spryloom has no file storage for an app, and
uploads: trueis refused. Keep what matters in the database.
For a client deliverable that is one questionnaire or one sign-off rather than a whole tool, see How to get a client to fill in a questionnaire or approve something your AI built.
Start here
In Claude Code, add the plugin once:
/plugin marketplace add spryloom/claude-plugin
/plugin install spryloom@spryloom
Then say "publish this for my client, only people I invite, and make megan@yourclient.com an admin". Without the plugin, from the app's folder:
npx -y spryloom publish