A pull request review workflow for client content edits works like this: the client's change is saved on its own branch instead of the live branch, GitHub opens a pull request that shows exactly which lines changed, a preview deployment builds the site with that change, and a developer or editor approves it before it is merged and goes live. Routine edits such as a new phone number can skip review; edits that touch headings, page structure or code should not. The rest of this guide covers how to decide what goes through review, how to set it up in GitHub, what a reviewer should check, and when the workflow is more process than a site needs.
Why Use Pull Requests for Content at All
On a site whose content lives in a Git repository (Markdown, MDX, JSON or component files), every edit is already a change to files. A pull request is simply the place where a proposed change waits for a second pair of eyes. GitHub's documentation on pull request reviews says reviewers "can also comment on specific lines, suggest exact changes, and discuss implementation details."
For client content, that gives you three things a plain "save" button does not:
- A diff. The reviewer sees the old text and the new text side by side, not a whole page they have to compare from memory.
- A preview before it is live. Hosting platforms build a separate copy of the site for the branch, so the change can be checked on a real page.
- A record. Who asked, what changed, who approved it and when, all kept in the repository's history.
The cost is waiting. A change that needs approval is not live until someone approves it. That is why the most important decision is not how to review, but what to review.
Decide What Goes Through Review
Sending every typo fix to a pull request turns the developer back into the bottleneck the client was trying to avoid. A workable split has three groups.
Commit directly
Edits where a mistake is cheap and obvious:
- Body text, service and product descriptions
- Prices, phone numbers, addresses, opening hours
- Image swaps and alt text
- Link targets and button labels
If one of these is wrong, the fix is another quick edit.
Review as a pull request
Edits that are easy to make but have effects the client may not see:
- Page titles, meta descriptions, H1 and H2 headings (they shape how a page appears in search, see our guide to SEO-safe edits to titles, H1s and meta descriptions)
- Text in shared parts of the site such as the header, footer or navigation
- Legal text: privacy notices, terms, cookie wording
- Any change outside the content files, in components, styles or configuration
Hand to the developer
Requests that are not edits at all: a new page, a new section, a form, a layout change. These start as a request with the client's wording attached, and the developer builds them, usually in a pull request of their own.
Our guide to content editing guardrails for client websites goes deeper on sorting a site into levels like these.
Set It Up in GitHub
Protect the live branch
The live branch (usually main) should not accept direct pushes for anything that needs review. GitHub's docs on protected branches describe a rule under which "collaborators can only push changes to a protected branch via a pull request", and an option to require approving reviews before merge.
Two settings matter for content work:
- Required approvals. One approving review is usually enough for content. More than one slows clients down without adding much.
- Dismiss stale approvals. GitHub can "dismiss stale pull request approvals when commits are pushed that affect the diff". Turn this on, so an approval always refers to the text that will actually go live, not an earlier draft.
If routine edits should still commit directly, the tool that makes them needs permission to push to the protected branch, while people and everything else go through pull requests. GitHub lets you restrict who may push, so plan this before you switch protection on.
Route reviews to the right person
A CODEOWNERS file maps folders to reviewers. Assign the content folders to whoever approves wording (an account manager or editor) and src/ and config files to the developers. Branch protection can then require a code owner's approval, so a heading change goes to the editor and a component change goes to a developer.
Turn on preview links
A reviewer should never approve content from a diff alone. Line breaks, long words and text inside a button look different on the page.
- Vercel's preview deployments give each branch a "branch-specific URL" that "always points to the latest changes on that branch", and the docs note that "you'll typically see links appear in your Git provider's PR comments".
- Netlify's Deploy Previews build each pull request at its own address (the docs' example is
deploy-preview-42--mysitename.netlify.appfor pull request 42) and show "a Deploy Preview status" on the pull request.
Other hosts have similar features. If yours does not, the reviewer has to run the site locally, which in practice means review gets skipped.
What a Reviewer Should Check
A content review is short. It is not a code review. A checklist keeps it under a few minutes:
- Is the change only what was asked? The diff should touch the lines the client mentioned. Unrelated changes in the same pull request are the main warning sign.
- Does it read correctly on the preview? Check the page on a phone width as well as desktop.
- Did a title, H1 or meta description change? If so, look at the page's queries in Search Console first and make sure the words people search for are still there.
- Are numbers and contact details right? Prices, phone numbers and dates are where a typo costs real money.
- Is anything structural hidden in it? A changed link to a page that no longer exists, a removed heading level, an edited slug.
- Is the client's intent clear? If not, ask in the pull request before changing it yourself.
GitHub gives you three outcomes for a review: Comment, Approve, and Request changes. Use Request changes when the client should rewrite something, and a suggested change when you can fix it yourself: GitHub's docs on incorporating feedback explain that you can apply suggestions "directly in a pull request if you have write access to the repository", and that a batch of suggestions becomes a single commit.
Write the pull request title in the client's words ("Update spring opening hours on the contact page"). The history then reads as a list of requests, which makes it easy to answer "when did we change that?" months later.
Keep Clients Out of the GitHub Interface
The workflow above assumes someone opens the branch and the pull request. Most clients will not use GitHub, and they should not have to. There are three common ways around that:
- A Git-based CMS with an editorial workflow. Decap CMS describes its editorial workflow as "an interface for drafting, reviewing, and approving posts"; behind the scenes it works with branches and pull requests. This fits content that is already structured into collections. Our explainer on what a Git-based CMS is compares the main tools.
- The developer opens the pull request from an email or ticket. Reliable, but the developer is back in the loop for every reviewed edit.
- A chat or form tool that opens pull requests for the client. The client describes the change, the tool prepares the branch, and the reviewer sees a normal pull request.
When Pull Request Review Is the Wrong Fit
Review adds a step, and that step needs someone on the other end. It is a poor fit when:
- Nobody is assigned to review. A pull request that waits a week is worse than a direct edit with an easy undo.
- The client edits a lot of routine text. Review the risky few, not the routine many, or the client will stop editing.
- The content changes by the hour. Event listings, stock levels or news belong in a database or a CMS built for frequent publishing, not in reviewed commits.
- The site is not in Git. On a hosted builder or a database CMS, use its own drafts and roles instead.
Where CMS Chat Fits
CMS Chat is built around this split. It connects to a site's GitHub repository through a GitHub App on the chosen repository, scans it and maps the editable zones (text, images, links, prices in TSX, MDX, Markdown, HTML and JSON files). Clients ask for changes in plain language in a chat. As the how it works page puts it, each file edit "is a plain Git commit in the site's repository, under the name of the person who asked", and "riskier edits arrive on a review branch as a pull request". Code changes outside the safe zones arrive as a pull request too, so your branch protection, required reviews and preview deployments apply to them like to any other pull request.
Page titles, meta descriptions and headings show a plain-language warning before anything changes, and with the optional Google Search Console connection that warning can say whether the element ranks. Each change appears in the change list and can be reverted. For agencies, client portals keep each client's sites, invites and activity history separate; see CMS Chat for agencies. To make the same edits from Claude, ChatGPT, Claude Code or Cursor, see the MCP endpoint.
Quick Setup Checklist
- Decide which edits commit directly and which go through review. Write it down per site.
- Protect the live branch: pull requests required, one approval, stale approvals dismissed.
- Add a CODEOWNERS file so content and code reach different reviewers.
- Turn on preview deployments and check that the link appears on each pull request.
- Give reviewers the six-point checklist above.
- Look at review times after a month. If pull requests wait more than a day or two, review fewer kinds of edit.