# Answer owner requests, undo and roll back

> Reading an owner's request, publishing the change, undoing one change, rolling the whole site back, and sending a change to the owner to approve first.

For builders who look after a site the business has bought.
It covers reading an owner's request, publishing the change, undoing one change, rolling the whole site back, and sending a change to the owner to approve first.

Saltmere Marina has now bought its site, and it is published at its own domain, `saltmeremarina.ca`. Its owner, Dana MacLeod, never edits the site's files. When something should change, Dana signs in to the owner panel at `app.websitestrategy.com` and opens **Change**. There Dana opens a page of the site, points at the part to change and types what should change. Sending it makes a numbered **request**, the one `ws requests` lists. (**Support** in the owner panel is for questions to the team, and makes no request.) It goes into a queue that builders and their coding agents work through, and the site's builders get an email. Here Jordan picks it up.

## 1. Read the request

Dana selects the sentence with the diesel price in the fuel dock post and types "Diesel is $1.89 a litre now."

```
$ ws requests
Open requests for "Saltmere Marina":
  1  Dana MacLeod, 10:02 AM   "Diesel is $1.89 a litre now."
```

```
$ ws requests 1
Request 1 from Dana MacLeod (owner), 10:02 AM, on version 3:
  "Diesel is $1.89 a litre now."

Dana selected this sentence on saltmeremarina.ca/news/fuel-dock:
  "Diesel is $1.79 a litre."
It comes from _data/news/2026-11-02-fuel-dock.md, line 6.
Its French copy: _data/fr/news/2026-11-02-fuel-dock.md, line 5.
Rebuilt from what Dana's browser showed: https://ops.websitestrategy.com/sites/s-kqm7qrxztcwxrrpdnfvbcebszd/requests/1/picture.png
```

The picture in the last line is rebuilt, not a screenshot of Dana's own screen. When Dana selected the sentence, Dana's browser sent the platform a copy of the page as it was shown: the screen size, the scroll position, any open menu and what was typed in forms. The platform reopened that copy with the site's scripts turned off and took the picture, so it matches what Dana saw. The one exception is a part a browser does not let a script read, such as some 3D scenes, which shows as a grey box. [How the platform works inside](https://docs.websitestrategy.com/reference/how-it-works/#pointing-at-part-of-a-page) explains how the picture is made.

The platform records which file and line made each part of every page it builds, including parts filled in from data files. So the request names the data file, not the page around it. Some parts have no file and line, such as text a script writes into the page. Then the request names the closest enclosing part that has a file and line, and the script files the page loads, and the rebuilt picture of what Dana saw shows the rest.

## 2. Make the change

Change `$1.79` to `$1.89` in the English post and `1,79 $` to `1,89 $` in the French one. Check them with `ws preview`, commit, then push them as the answer to request 1:

```
$ git add -A && git commit -m "diesel price"
$ ws push --request 1
Built 10 pages.
Checks passed: speed, accessibility, links, forms, translations.
Published version 4 of "Saltmere Marina" at https://saltmeremarina.ca.
Dana MacLeod gets an email: request 1 is done.
```

The change is published as soon as the automatic checks pass, like any other. That holds whether Jordan makes it, or an agent works through the queue and makes it. Builders are trusted, and an owner who asked for a change should not have to approve it again.

## 3. Undo one change

Dana sends a second request: "Sorry, $1.89 is the gas price. Diesel didn't change." Reverse version 4 as the answer to that request:

```
$ ws undo 4 --request 2
Made version 5. It reverses what version 4 changed (2 files) and keeps
everything else as it is.
Published version 5 of "Saltmere Marina".
Dana MacLeod gets an email: request 2 is done.
```

`ws undo` reverses only that one version's changes, the way `git revert` does, so anything published after it stays. It is published at once, after the same checks. If a later version changed the same lines, `ws undo` refuses and names the file; make that change by hand instead. Each builder who works on the site has their own copy of its folder, on their own computer. Their next `ws push` is refused until they run `git pull`, as for any change made elsewhere.

## 4. Roll back the whole site

To put every file and setting back the way it was in an earlier version, list the versions and roll back to one:

```
$ ws versions
  5  Today 10:31 AM   Jordan Bell   Undo version 4 (request 2)
  4  Today 10:12 AM   Jordan Bell   Request 1: diesel price
  3  Nov 14 9:40 AM   Jordan Bell   Footer change
  2  Nov 14 9:14 AM   Riley Park    News: winter storage
  1  Nov 13 4:05 PM   Jordan Bell   First version
```

```
$ ws rollback 2
This makes version 6 with the files and settings of version 2. It removes the
changes in versions 3, 4 and 5. Type "roll back" to go ahead: roll back
Published version 6 of "Saltmere Marina" at https://saltmeremarina.ca.
```

`ws rollback` asks before it replaces the live site. A coding agent, or anything else with no terminal to answer in, runs `ws rollback 2 --yes` instead.

A rollback is a new version too, published at once after the checks. Nothing is ever deleted, so you can roll back to version 5 the same way. Staff can roll a site back the same way on the ops panel, at `ops.websitestrategy.com`.

## 5. Ask the owner to approve a change first

The rollback in step 4 made a commit on the platform, so bring the folder up to date first with `git pull`.

Some changes are worth showing the owner before visitors see them, such as a new photo of the dock on the About page. Replace `photos/dock.jpg` with the new photo, commit it, then push that one change with `--needs-approval`:

```
$ git add -A && git commit -m "New dock photo"
$ ws push --needs-approval
Sent to Dana MacLeod for approval as change A1. Nothing is published yet.
This folder is back to version 6, so your next publish cannot carry A1.
Your change is kept on branch approval/A1.
```

Dana gets an email with a link to the change in Dana's account. Signed in, Dana sees a preview of it and two buttons:

- **Approve.** The platform applies A1 to the newest version, as a patch, and publishes it as a new version.
- **Not quite.** Dana points at what should change, as a request. `ws withdraw A1` brings the change back into Jordan's folder to fix.

A change waiting for approval is not a version, and anyone can publish other changes meanwhile. The approval is refused if A1, applied to the newest version, does not build or fails a check the platform requires before publishing, or if someone changed the same field after Jordan sent A1:

- the same field of a data record, such as a post's `title`;
- the same named string in a locales file, such as `menu.about`;
- the same language's part of one `{% text %}` block, the block that holds a page's longer writing with one part for each language.

A photo has no fields, so the whole file counts as one: here the approval is refused only if someone replaced `photos/dock.jpg` after A1 was sent. Then the platform tells Jordan, who makes the change again.

A site can also be set so that each publish, undo and rollback waits for the owner, with `ws site --approval required`. Setting changes still publish without waiting. Most sites never need that: getting an owner to look at a site at all is often the slowest step in web work.


