Blog

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.

you: owner client: admin sign-in The app its own database invited by you
You stay the owner and let the client's team in. The client is an admin inside the app.

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.

A new HR coordinator starts→Megan tells you; you run spry invite
Someone leaves→spry uninvite, effective on their next click
The client wants to handle seats without you→The app belongs in their workspace

Inside 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.jordanconsulting-com.spryloom.app/~label

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
Who can use it
  • Shared withPeople who were invited
  • Administratorsjordan@jordanconsulting.com, megan@yourclient.com
Where it came from
  • Made byjordan@jordanconsulting.com
  • Sign-inA link sent to your work email
Open the app

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:

onboarding-tracker
# 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: true is 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

Spryloom publishes apps and pages built with a coding agent behind sign-in, for the people you invite. This article was written by the people building it.

Get started free