Blog

How to see who changed what in a tool your team shares

A number changed in the tracker and nobody remembers doing it. Where "who changed this" comes from in spreadsheets, form tools and apps, why it has to come from sign-in rather than a name field, and how Spryloom records it.

Every shared tool eventually gets the question. The vendor's payment date in the tracker moved. A step in the release checklist was ticked that nobody remembers ticking. A discount in the pricing sheet is now 30% instead of 20%. Who did that, and when?

If the tool can't answer, the team stops trusting it, and the spreadsheet comes back as the place where things are "really" kept.

This article is about getting a real answer. We make Spryloom, and the last part describes how it records changes, so read that part knowing who wrote it. The other options are good, and most teams already use one of them.

Two questions, not one

"Who changed this" is usually one of two questions, and they need different records:

Question 1

Who changed the data?

A record, a row, a status, a number.

Question 2

Who changed the tool?

Someone published a new version, and now the totals are calculated differently.

A tool that only answers one of them leaves the other as guesswork. And both share a rule:

The name has to come from sign-in, not from the person.A "Your name" box records whatever was typed, including a colleague's name.

People mistype and use nicknames too. A record of who did something is only worth having if nobody can write someone else's name into it.

Option 1: a spreadsheet's version history

Google Sheets and Excel for the web both keep version history, and can show who edited a cell and what it was before. Everyone signs in with their own account, so the name is real. For a team that works in a spreadsheet anyway, this is a strong answer and costs nothing extra.

Where it strains: the history is a list of edits to a grid, so answering "who moved this payment date" can mean stepping back through versions. Anyone with edit access can change any cell, including someone else's row. Protected ranges help, at the cost of setup.

Option 2: a form tool

Google Forms, Microsoft Forms and similar tools can require sign-in and record the respondent's address with each answer. That gives you a true "who submitted this". It's a good fit for requests and sign-offs.

A form records submissions, not changes. Once answers land in a sheet, edits to them are back to Option 1.

Option 3: an audit table in the app

If your agent built the tool as an app, it can keep its own history: a table with one row per change, holding who, what, when, and the old and new values. This is what most well-built internal tools do, and it can be exactly as detailed as you need.

It depends on one thing the app doesn't have by default: knowing who the person is, reliably. If the app has its own login, the audit table is only as trustworthy as that login. If it takes a name from the request, it's no better than the form box.

Option 4: let sign-in stamp every change

This is what Spryloom does. Spryloom runs apps and pages your agent built behind sign-in. Everyone signs in with an emailed link before anything reaches the tool, so the tool always knows who each person is, and nobody can claim to be someone else.

Dana signed in as dana@… A saved record savedBy dana@… savedAt Mon 09:14 updatedBy chris@… updatedAt Wed 16:02 Your name: ___ not needed the names come from sign-in, so a page can't write the wrong one
Who saved a record, and who changed it last, are written by Spryloom from sign-in.

Pages that save data

Many team tools are a few lists: a checklist, a request log, an equipment checkout. Spryloom can keep those as a page that saves data: the page your agent wrote, plus lists declared in its manifest. There's no server and no database to set up. How to make a checklist your whole team can use, without building an app walks through one.

Every record in those lists is stamped by Spryloom with four fields: savedBy and savedAt when it is first saved, and updatedBy and updatedAt each time it changes. The addresses come from the person's sign-in. The page's own code can't set them, so it can't get them wrong.

Three more rules make that record mean something:

  • Only the saver, or the page's owner and admins, can change or delete a record. If Chris tries to edit Dana's entry, it is refused with a message the page can show him.
  • Lists can be own. Each person sees only what they saved; the owner and admins see everything. That suits requests or sign-offs.
  • No name or email field in a form. The page asks who is signed in and shows that. Tell the agent, or let the Spryloom skill tell it.

To get the whole record out, with the stamps, run spry data export vendor-tracker. It saves every list as JSON and CSV. The CSV starts with id, savedBy, savedAt, updatedBy and updatedAt, then the page's own fields, so a spreadsheet can sort by who changed what last.

Who read the data from outside the page

A page's records can also be read without opening the page: by an agent, such as Claude in Claude Code or Claude.ai through the Spryloom connector, or by an export. That's useful ("what's still open on the tracker?"), and it's also a change in who can see the data. So it is logged:

vendor-tracker
spry data log vendor-tracker
# one line each: when, who, agent read or full export, how many records
# or, if nobody has:
Nobody has read vendor-tracker's data from outside the page.

An agent reads as the person who connected it, sees only what that person sees in the page, and can change only records that person saved.

Apps

When a tool needs more than lists, it's an app with its own Postgres database, and the agent writes the audit table from Option 3. The difference is where the name comes from. Spryloom sends every request to the app with two headers, x-spryloom-email and x-spryloom-role, and removes any copy of them a browser sends before deciding anything. So the app can write x-spryloom-email into its history table and trust it. If a form also carries an author field, the app should ignore it and use the header.

Who changed the tool

Spryloom keeps its own log of every publish and rollback, sign-in, invitation and access change, with who did it and when. The dashboard shows publishes, rollbacks, sign-ins, invitations and refused attempts. spry apps shows which version is live. If version 4 broke the totals, you can see who published it, and spry rollback vendor-tracker puts version 3 back. A rollback changes which code runs. It doesn't undo changes to records.

What it doesn't do

  • A record shows the first save and the latest change. It doesn't show each edit in between, and it doesn't show the old value. If you need every step, ask the agent to save each change as a new record in a list, rather than overwriting one, or to keep an audit table in an app.
  • It records who, not why. If the reason matters, the page needs a note field.
  • Admins can change anyone's records in the page. Choose admins with that in mind. Agents can't: through the connector, an agent changes only the connected person's own records.
  • It's for people who sign in. Everyone using the tool has an address on it. There are no anonymous entries.

Start here

In Claude Code, add the plugin once:

/plugin marketplace add spryloom/claude-plugin
/plugin install spryloom@spryloom

Then say "make this a page that saves data, with no name fields, and publish it for the people I invite". In Claude.ai, add the connector https://app.spryloom.com/mcp under Settings → Connectors, and Claude can read a page's records and add to them from the chat.

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