The words we use in the product and the docs, with the short version and the longer one.
Recording what a user did in a web or mobile app and playing it back later.
Session replay captures the DOM (the structure of the page), every change to it, and the user's interactions, then reconstructs them in a sandboxed player. It does not record pixels or screen video. Modern tools attach console logs, network requests, errors, and performance timings to the same timeline so an engineer can see what the user saw and why it happened.
A serialized copy of the page's element tree at a moment in time.
The recorder walks the document and assigns a stable id to every node, capturing tags, attributes, text, stylesheets, and shadow roots. Everything that follows is expressed as changes to this snapshot, which is why a snapshot is also called a checkpoint.
The ordered list of changes to the DOM after a snapshot.
A MutationObserver reports added and removed nodes, attribute changes, and text edits. Because each change depends on the ones before it, the stream is causal: dropping one silently corrupts the replay. Backstory never drops a single mutation; under pressure it abandons a range, records a gap marker, and starts a new checkpoint.
A fresh full snapshot that resets the mutation chain.
Checkpoints bound the cost of seeking in the player and make it possible to recover from loss. Backstory takes one every five minutes, after heavy route changes, when memory pressure forces a drop, and at every segment boundary.
An explicit record that a time range was not captured, and why.
Rather than showing a wrong picture, the player shows a hatched region with the reason: device memory pressure, offline, storage quota, paused, or hidden tab. AI analysis honors the same gap, so a summary never invents what happened inside it.
Replacing sensitive text and inputs before they leave the device.
Backstory masks at capture time, not in playback, so the server never receives the original. Privacy mode is on by default and masks all text with layout-preserving glyphs. Passwords, card details, and one-time codes stay hidden even with privacy mode off.
Three or more clicks within a second on the same spot.
A classic frustration signal: the user expected a response and did not get one. Backstory detects rage clicks, dead clicks (no visible response), error clicks (click followed by an error), and twenty other signals, then clusters them across sessions.
A click on something that looks interactive but nothing happens.
Detected when a click on an element with a pointer cursor or interactive role produces no DOM change, navigation, or network request within one second.
Buffer first, upload only if something interesting happens.
The SDK keeps the first 30 seconds in memory and uploads the session only when a trigger fires (an error, a rage click, a custom event) or when baseline sampling selects it. Healthy sessions are never stored and never billed.
The pointer that ties an AI claim to the moment it came from.
Every claim in an explanation carries one, and the player turns it into a jump link, so you land on the moment and judge it yourself. A claim without a citation is never shown. This is what separates a grounded answer from a plausible one.
One continuous run of the app in a tab, unbounded in length.
A visit is split into 4-hour segments for storage and processing, at checkpoint boundaries so the cut is invisible. Kiosks and telehealth workstations can run for days as one visit.
A low-cost recording profile for screens that run for hours without interaction.
After a configurable idle period the recorder keeps only keyframes and events, holding a 60-second pre-roll buffer in memory. Errors, disconnects, and custom triggers upload the pre-roll plus a full-fidelity burst, so the replay shows the minute before the problem.
The state machine that trades recording quality for memory and bandwidth.
Five levels from HEALTHY to PAUSED. Downgrades are immediate; upgrades wait for a hold window. Pointer sampling, canvas quality, console filtering, and network detail all follow the level, so the recorder never exceeds its memory budget.
A support agent watches the user's page live, rendered from the same DOM stream as the recording.
No screen sharing and no WebRTC video are needed; masking still applies. One Support access grant covers chat, drawing, and remote control, while voice requires a separate confirmation.
Deleting data by destroying the key that encrypts it.
Every end user's chunks are encrypted with their own data key. A GDPR erasure request destroys the key, making every stored object unreadable instantly, even in immutable storage and backups.
Google's user-centric performance metrics: LCP, CLS, INP, FCP, TTFB.
Backstory captures them with attribution (which element was the LCP, which shift moved before a misclick) and shows them on the replay timeline and in per-route dashboards.
