You have the staging URL open, the build looks finished, and someone is waiting on your sign-off. The temptation is to click around for two minutes, see nothing obviously broken, and say ship it. That is how a broken checkout button, a 404 on the pricing link, and an unreadable mobile header all reach production on the same day.
Here are three checks that catch most of what slips through, each one you can run in a browser tab and capture as a pinned still. Run them as part of a staging site review and the developer gets exactly what failed, marked on the screen, instead of a vague "something looked off on the pricing page."
Click every link and button that leaves the page
Do this first, because it is the cheapest to run and the most common to fail. Staging sites inherit links from local dev, from a previous environment, or from hardcoded production URLs that resolve to nothing on the staging domain. The nav looks right. Then you click "Pricing" and land on a 404, or "Book a demo" opens a form that posts to a dead endpoint.
Walk the primary nav, the footer, and every call-to-action button on the pages that matter. When one breaks, capture the screen with the broken result visible (the 404 page, the wrong destination, the console error if there is one), drop a numbered pin on the link you clicked, and write what you expected versus what happened. A still with the destination URL in the address bar tells the developer more than three sentences of description.
The failure mode when you skip this: the link works for you because your browser cached the production version, so you never see the staging break. The first person to hit it is a real visitor after launch. Click deliberately, do not trust the hover.
Open the key pages on a phone-width viewport
Most staging review happens on a laptop because that is where the reviewer works. The visitor often arrives on a phone. A header that collapses fine at 1440px wide can overlap the logo at 390px, a table can run off the right edge, and a sticky banner can eat half the screen with no way to dismiss it.
You do not need a physical phone. Narrow the browser window or use the device toolbar in your browser's dev tools, then look at the pages a cold visitor hits first: homepage, pricing, and whatever your main signup or contact flow is. Capture each screen at phone width and pin the specific element that breaks. Drawing a box around an overlapping element on the still makes the problem unambiguous.
If your reviewer is a client who only has a phone, remember phone browsers cannot grab the screen, so they take a normal screenshot and add it to the review. The same format works either way. This matters more than it sounds: your designer reviews on desktop and your client reviews on a phone, and the two see different bugs.
The failure mode: desktop looks clean, nobody checks narrow, and the first mobile visitor meets a layout that is unusable. Phone traffic does not wait for a hotfix.
Walk one real task end to end, not just the pages
Loading a page tells you the page renders. It does not tell you the thing works. The check that catches real breakage is picking one task a user actually performs (sign up, add to cart and reach checkout, submit the contact form) and doing it start to finish, including whatever comes back by email.
Staging environments are where integrations quietly fall apart. The form submits but no confirmation email fires because the mail service points at production keys. The checkout reaches the payment step and stalls because the test gateway is not wired up. You only see these by completing the task, not by looking at it. Capture a still at each step, and pin the exact point where the flow stops behaving. A flow walkthrough that includes the emails catches what a page-by-page scan never will.
The failure mode: every page loads, so the build "passes," and the broken signup only surfaces when a real user cannot complete it and leaves. By then the cost is a lost account, not a staging note.
Why pinned stills beat a shared screen or a list
Each of these checks produces something specific: a broken link, a mangled mobile header, a stalled flow. The question is how you hand that over. A live screen share means the developer has to be online at the same time and cannot refer back to it later. A plain text list forces them to reconstruct what you saw.
A captured still with a numbered pin and a one-line comment is the opposite. The developer sees the exact element, the exact state, and your note, all in one place, whenever they open it. Pins and drawings bake into the exported image, so the mark survives the handoff instead of getting lost. You can publish the whole pass as a review link anyone opens with no login, export it as a bug report, or if you own the repo, send it straight to GitHub as an issue. An AI coding agent that opens the link reads the clean markdown and the screenshots directly, so the fix request lands ready to act on.
Cobalt Capture runs in a browser tab with no install, no extension, and no password, which is the point when you are reviewing a staging site between other work. You can start a review and run the pass for free; a review stays editable for 7 days before it goes read-only for you, and Pro at $5 a month keeps everything editable with no cutoff. The shared link keeps working for your team either way.
Next time a build is "done," run these three before you say so: every link, phone width, one full task. Capture what fails, pin it, and send the link.