Blog

How to retire an internal tool without losing its data

The project ended, the audit passed, the team moved on. Most tools your agent builds should last as long as the problem they solve, and no longer. How to stop one, keep what it holds, bring it back if you need it, and delete it only when you mean to.

When building software took months, nobody built a tool for a problem that would be gone by spring. Now a coding agent builds one in an afternoon, and that changes what a tool is for. A tracker for one office move. A sign-off page for one audit. An intake log for one client engagement. A request queue for the three months a team is short-staffed.

That kind of software should last as long as the problem, and then stop. The part people skip is the stopping. The tool sits there, half-used, with real data in it, until someone asks "is that still running?" and nobody is sure whether it's safe to turn off.

This article is about retiring a tool on purpose: what to keep, in what order, and how to bring it back if the problem returns. We make Spryloom, and the commands below are ours, so read it knowing who wrote it. The order of the steps applies wherever your tool runs.

Why retiring needs a plan

Three things make it easy to get wrong.

  1. The data outlives the problem. The office move is over, but finance will ask in March what was ordered and who approved it. An audit sign-off page is evidence. A client intake log may be something you promised to keep, or promised to delete.
  2. Stopping and deleting look alike. Both make the tool go away. Only one of them can be undone, and the difference is usually a menu item apart.
  3. Nobody owns the end. The person who built the tool has moved on to the next one. If the end isn't a decision someone makes, it doesn't happen, or it happens by accident.

So the order matters: copy the data, stop the tool, wait, and delete only when you're sure.

1. Copy export 2. Archive data kept 3. Wait still yours 4. Delete gone restore can be undone can't be undone
Everything left of the line can be undone. Deleting is the one step that can't, so it comes last.

The usual ways tools end

Most common

Left running

Still has a sign-in page. The people invited can still open it.

  • Harmless until someone finds the client list in it a year later
By accident

Turned off by whoever pays the bill

An account is cancelled or a free plan is cleaned up.

  • The data goes too, on someone else's schedule
Sometimes right

Moved into a proper system

The small app was only ever the bridge.

  • Records go to accounting, HR or ticketing
  • The export is still step one

Retiring a tool on Spryloom

On Spryloom, a tool your agent built is either an app (its own server and Postgres database) or a page that saves data (lists of records, no server). The steps differ slightly, so here are both. Take Emily, who runs operations and had her agent build an equipment request app for an office move that finished last month.

Step 1: copy the data out first

Do this while the tool is still running, because an archived app doesn't answer, and its data can't be read through it.

An app's records, in its own database→Ask your agent for an admin-only CSV download
The app's history: manifest, sharing, versions, audit→spry export
A page's saved records→spry data export

For an app, Spryloom doesn't read the database rows for you, so the export comes from the app itself. Ask your agent: "add a page only admins can open that downloads every request as a CSV." It uses the role the app already knows (x-spryloom-role is admin for Emily), and you publish once more. Download the file and put it where your team keeps records. Then save the app's own history from Spryloom:

spry export equipment-requests > equipment-requests-spryloom-export.json

That file is the record of what the tool was and who used it. It says plainly that the database rows aren't in it, which is why the CSV comes first.

For a page that saves data, Spryloom keeps the records, so one command copies them all:

spry data export equipment-requests

It saves every record into a folder named equipment-requests-data/, as JSON and CSV for each list, each record with who saved it and when. Lists the page no longer uses are included. Only the page's owner and admins can run it, and every export is written to the page's access log. A cell a spreadsheet would run as a formula is written as text, so the CSV is safe to open.

Open the file and check it before going on. A file you haven't looked at is a guess.

Step 2: archive it

spry archive equipment-requests

The app stops serving. Its scheduled jobs stop, so nobody gets a reminder about a move that's over. Its database and data stay exactly as they were.

Many tools never need more. Archiving is the right answer for "we're done for now", and for anything you might be asked about later.

One thing to know: an archived app still counts toward the 10 apps a workspace can have, because its data is still kept. Pages don't count toward it.

Step 3: wait, and restore if you need it

The problem comes back more often than people expect. The next office move. Next year's audit. If it does:

spry restore equipment-requests

That starts the last published version again, with the same data, at the same address, for the same people. It doesn't rebuild the app or change its database. Nobody has to be invited again.

How long to wait is your call, and usually not a technical one. Ask whoever will be asked about the data: finance, the client, whoever owns the records. Write the date down somewhere other than your memory.

Step 4: delete it, last

Before you delete: have your copy, and open it. Deleting removes the app's machine, its database and the data in it, and its secrets. For a page, its files and saved records. Nobody can get them back.
spry delete equipment-requests equipment-requests

The name goes in twice, on purpose: typing it again is how you say you meant this tool and not the one next to it. The command says it's done only after checking each part is gone. If one isn't, it names it, and you run the command again.

You don't need to delete a tool to stop it costing anything: an app nobody is using goes to sleep, with no machine running and its database suspended. Delete is for when the data should be gone.

Doing it from your agent

You don't have to type most of this. In Claude Code, "we're done with the equipment requests app: export its requests, then archive it" is enough: the agent adds the export and publishes it, saves the spry export file, and runs spry archive for you, then tells you what it saved and where. Deleting stays a command you run yourself.

What it doesn't do

  • Spryloom doesn't export an app's database rows. It never reads them, so the export has to come from the app, before you archive.
  • Rolling back isn't undoing. spry rollback changes which version of the code runs. It doesn't put back records that were changed or deleted. Your own export is the only copy you control.
  • Archived apps aren't free of the limit. They still count toward the workspace's 10 apps. Delete one you'll never need to make room.
  • There's no handover button. If someone else should look after a tool when you leave, make them an admin of it in its spryloom.yaml and publish again, and keep the export somewhere the team can reach.

Start here

Before your next tool goes live, decide how it ends: who will be asked about its data, and for how long. Then, when the day comes:

retiring a tool
# 1. copy the data out, while it still runs
spry export <app> > <app>-spryloom-export.json
spry data export <page>
# 2. stop it, data kept
spry archive <app>
# 3. if the problem comes back
spry restore <app>
# 4. last, and only when you mean it
spry delete <app> <app>

If you haven't installed the command, npx -y spryloom works in place of spry everywhere above. For the first steps of a tool's life, see how to test an AI-built app before coworkers use it.

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