> Canonical: https://drkishanrees.com/learn/shipping-updates/

# How do I make updates to the site after it's live?

*Changing a live site is two moves, not one: a commit saves the work, a push ships it, and on this site only the push goes live. Knowing which command is which is the whole of the safety.*

Launch & Costs. 3 min read.

First published 7 August 2026

<TrueFalseCard statement="Once your site is live, editing a page changes what visitors see straight away." correct={false}>

Editing a page changes only the copy on your own computer. Visitors see nothing new until you publish, and publishing is a separate, deliberate step. Saving your work and publishing it are two different acts, and only one of them is public.

</TrueFalseCard>

When a model lists the questions a beginner asks about building with AI, this one always arrives
near the end, once the site exists: it is live, so how do I change it without breaking it? The
honest answer is that the fear rests on a single confusion, and clearing it up is most of the
session. Changing a live site feels like one dangerous act. It is really two separate ones, and only
the second is the one that goes live.

## What is the difference between saving and publishing?

Two commands, and only one of them is public. Neither needs you to read code; they need you to know
which command does what.

A **commit** is a save, not a broadcast. It takes a snapshot of your changes and files it in the
project's history under a short label, so you can always return to it. It changes nothing that
anyone else can see. Commit as often as you like; each one is just a checkpoint.

A **push** is the publish. It sends your saved commits to the host. On this site the host is
configured so that a push to the main line rebuilds and serves the site automatically, in about a
minute. That push, and only that push, is the act that goes live.

So editing saves nothing on its own, a commit saves without publishing, and a push to the main line
is the single command that reaches the world.

## How do I hold a change back until it is ready?

Work it on a **branch**, a parallel copy of the project. You can commit to a branch, and even push
the branch, and the live site does not move, because only the main line deploys. You keep unfinished
or unreviewed work on a branch, and fold it into the main line when it is ready. That folding in is
the moment it can go live, and it is yours to choose.

So the safety is not a nervous ritual. It is one fact held clearly: a commit saves, a push
publishes, and a branch keeps work off the live line until you decide.

## Where can I see this on the site?

Every page you are reading arrived by this exact route. The change was saved as a commit, pushed to
the main line, and rebuilt and served by the host, which the [colophon](/colophon/) records: the
site is static, built with Astro and hosted on Cloudflare Pages. The [Bot Crawls
study](/colophon/bot-crawls-001/) you can open from there went live the same way, no differently
from a typo fix.

The clearest proof is what did not happen. When I ship an update, the push carries exactly the
commits I saved and nothing I did not, so the rest of the site holds still while the one change
lands. And when a change is not ready to be seen, it waits on a branch or as an unpushed commit,
saved and safe, with the live site untouched until I decide. Making the change is the work;
publishing it is a separate, deliberate second step.

## So can I change a live site without fear?

You can, once you stop treating it as one act. Saving is not shipping. Commit as often as you like,
because a commit is only a checkpoint in the history. Publishing is the separate push to the main
line, and knowing that one command is the live one is the whole of the safety. If you are not ready,
keep the work on a branch, off the live line, until you are. The tool does the deploying. Deciding
when a change is ready to be seen never stops being yours.

## Questions and answers

### What is the difference between saving and publishing a change?

A commit saves a labelled snapshot of your work into the project's history, and changes nothing anyone can see. Publishing is a separate step, a push, which sends the saved work to the host and triggers the live rebuild. You can save many times and publish once.

### Will my change go live the moment I make it?

No. Editing a file changes only the copy on your own machine. Nothing reaches the live site until you push the main line to the host, which then rebuilds and serves it in about a minute. Until that push, the live site is untouched.

### What if I am not ready for a change to be seen?

Work it on a branch, a parallel copy of the project. A branch can be saved and shared without touching the live line, because only the main line deploys. You fold it in when you are ready, and that is the moment it can go live.

## Related resources

- How this site is built and hosted, on the colophon: https://drkishanrees.com/colophon/
- The Bot Crawls, a study that went live by this route: https://drkishanrees.com/colophon/bot-crawls-001/

Cite as: Rees, Kishan. 'How do I make updates to the site after it's live?'. drkishanrees.com, first published 7 August 2026. https://drkishanrees.com/learn/shipping-updates/