What is session momentum in analytics?

Session momentum measures whether a visitor's engagement is accelerating or decelerating within a session. Increasing momentum — faster page transitions, deeper scrolling, more interactions — signals growing interest, while decreasing momentum signals disengagement.

What does navigation entropy measure?

Navigation entropy quantifies how random or focused a visitor's movement through a site is. It applies Shannon entropy to page-to-page transition patterns: low entropy indicates purposeful navigation toward a goal, while high entropy indicates exploratory or confused behavior. It helps distinguish between visitors who know what they want and those who need guidance.

How is attention score calculated?

Attention score combines active engagement signals — scroll depth, mouse movement over content areas, time spent on visible content, and interaction with page elements — to measure genuine content consumption rather than simple page load or time-on-page metrics.

Session Momentum, Navigation Entropy, and Attention Score

What These Signals Tell You

Session momentum, navigation entropy, and attention are scored signals computed in real time alongside ClickStream's 26 behavioral models. Session Momentum shows whether the visitor is accelerating (+) or decelerating (−) through your funnel — it is exposed in the Signals visitor snapshot as visitor.scores.sessionMomentum. Navigation Entropy is a 0–100 disorder score persisted with every scored event — low means purposeful movement, high means erratic. Attention is measured as seconds of meaningful interaction, distinct from raw time-on-page.

Business Actions: Use the Signals client to react in your own page code — surface a contextual CTA while momentum is strongly positive, flag high-entropy sessions for UX review, and use attention data to identify your most-read content and double down on what works.

Session Momentum

Session momentum measures the velocity and acceleration of a visitor's progression through your site. Unlike simple page-per-minute metrics, momentum captures the direction of movement: is the user moving purposefully toward a goal, or are they drifting aimlessly?

A high-momentum session typically follows a clear trajectory — landing page to category to product to cart. A low-momentum session meanders, backtracks, and stalls. By quantifying this in real time, you can identify the exact moment a session starts to lose steam and intervene.

The 7 Momentum Signals (Illustrative)

The weighted breakdown below is an illustrative sketch of the kinds of inputs that drive momentum — production weights are tunable per site rather than fixed coefficients:

Signal	Weight	Description
Funnel progression rate	0.25	Speed at which the visitor advances through defined funnel stages
Page-to-page transition speed	0.18	Average time between page loads (normalized for content length)
Forward navigation ratio	0.15	Ratio of forward clicks (deeper pages) to back-button usage
Engagement acceleration	0.14	Whether engagement score is increasing page-over-page
Search-to-click efficiency	0.10	How quickly the visitor finds and clicks what they searched for
Scroll velocity consistency	0.10	Steady scroll pace vs. erratic stop-start patterns
Session recency boost	0.08	Returning within 24 hours of a previous session gets a momentum bonus

Momentum Categories

The momentum score runs from −100 (losing steam) to +100 (accelerating); the bands below guide real-time action:

Score Range	Category	Pattern	Recommended Action
−100 to −40	Stalled	No forward progression, idle or stuck	Proactive help widget, navigation suggestions
−39 to −1	Drifting	Slow, aimless browsing with no clear direction	Content recommendations, guided pathways
0 to +40	Steady	Consistent pace, moderate funnel progress	Reinforce with social proof, related content
+41 to +75	Accelerating	Rapid funnel advancement, purpose-driven	Clear the path, reduce distractions
+76 to +100	Surging	Fast, decisive movement toward conversion	Minimize friction, show trust signals at checkout

Momentum Decay

Momentum decays when a visitor goes idle, so stale sessions do not carry artificially high momentum scores. When the visitor resumes activity, momentum recalculates from current behavioral signals rather than jumping back to pre-idle levels.

Under the Hood: An Illustrative Momentum Sketch

// Illustrative sketch — not the shipped implementation
function calculateMomentum(session: SessionState): number {
  const funnelRate = session.currentFunnelStage / session.totalFunnelStages;
  const transitionSpeed = normalizeTransitionTime(session.avgPageTransitionMs);
  const forwardRatio = session.forwardNavigations /
    Math.max(session.forwardNavigations + session.backNavigations, 1);
  const engagementAccel = session.engagementSlope;
  const searchEfficiency = session.searchClickTime > 0
    ? Math.max(0, 1 - (session.searchClickTime / 30000)) : 0.5;
  const scrollConsistency = 1 - session.scrollVelocityVariance;
  const recencyBoost = session.hoursSinceLastVisit < 24
    ? 1 - (session.hoursSinceLastVisit / 24) : 0;

  let score = (funnelRate * 25) + (transitionSpeed * 18) +
    (forwardRatio * 15) + (engagementAccel * 14) +
    (searchEfficiency * 10) + (scrollConsistency * 10) +
    (recencyBoost * 8);

  // Apply idle decay
  const idleSeconds = (Date.now() - session.lastInteractionTs) / 1000;
  if (idleSeconds > 30) {
    score *= Math.exp(-0.05 * (idleSeconds - 30) / 10);
  }

  // Center on zero: -100 (decelerating) .. +100 (accelerating)
  return Math.min(100, Math.max(-100, Math.round(score * 2 - 100)));
}

Navigation Entropy

Navigation entropy borrows from information theory to measure the randomness or disorder of a visitor's movement through your site. A visitor who moves in a logical, predictable sequence (home → category → product → cart) produces low entropy. A visitor who hops erratically between unrelated pages produces high entropy.

High navigation entropy is a strong signal of confusion, disorientation, or bot-like behavior. It complements the confusion model by focusing specifically on page-transition patterns rather than broader behavioral signals.

How Entropy Is Calculated

ClickStream computes Shannon entropy over the visitor's page-transition patterns. Each page-to-page transition is a category in the probability distribution: a visitor moving through a predictable path produces low entropy, while erratic hopping between unrelated pages produces high entropy. The formula produces a value between 0 (perfectly predictable — the session repeats the same transitions) and log₂(n) (maximum disorder — transitions spread uniformly across n distinct patterns).

This raw entropy value is then normalized to a 0–100 scale, where 0 is perfectly predictable navigation and 100 is maximum disorder.

Entropy Interpretation

Score Range	Category	What It Means	Action
0–20	Laser-focused	Extremely predictable navigation, single-purpose visit	Clear conversion path
21–40	Purposeful	Logical page flow with occasional exploration	Standard experience
41–60	Exploratory	Browsing broadly, trying different areas	Content recommendations
61–80	Disoriented	Scattered navigation, likely struggling to find something	Search suggestions, help widget
81–100	Chaotic / Suspicious	Extremely random or bot-like navigation patterns	Bot review, UX investigation

Under the Hood: An Illustrative Shannon Entropy Sketch

// Illustrative sketch — not the shipped implementation
function calculateNavigationEntropy(transitions: PageTransition[]): number {
  const transitionCounts = new Map<string, number>();
  for (const t of transitions) {
    const key = t.fromPath + ' -> ' + t.toPath;
    transitionCounts.set(key, (transitionCounts.get(key) || 0) + 1);
  }

  const total = transitions.length;
  let entropy = 0;
  for (const count of transitionCounts.values()) {
    const p = count / total;
    entropy -= p * Math.log2(p);
  }

  // Normalize to 0-100 relative to max possible entropy
  const maxEntropy = Math.log2(transitionCounts.size);
  const normalized = maxEntropy > 0 ? (entropy / maxEntropy) * 100 : 0;

  return Math.round(normalized);
}

Attention Score

The attention score measures how deeply a visitor is concentrating on your content at any given moment. It goes beyond engagement by focusing on focus intensity rather than interaction breadth. A visitor can be highly engaged (clicking many things) but poorly attentive (skimming quickly). Attention captures whether they are actually absorbing what you are presenting.

The 8 Attention Signals (Illustrative)

The shipped attention signal is measured as seconds of meaningful interaction with visible content. The table below is an illustrative breakdown of the kinds of behavior that separate genuine attention from a page that merely sits open:

Signal	Weight	Description
Reading pace	0.22	Scroll speed calibrated to content density (words per viewport). Slow, steady scrolling = reading.
Pause frequency	0.18	Number and duration of scroll pauses on content sections (not ads, not navigation)
Tab focus duration	0.15	Continuous time with tab visible and active (no alt-tabs)
Mouse tracking content	0.12	Mouse position following text flow (left-to-right, top-to-bottom sweep)
Text selection events	0.10	Selecting text to copy, highlight, or re-read indicates deep attention
Viewport stability	0.08	Low scroll jitter — the viewport stays stable while the visitor reads
Return-to-section	0.08	Scrolling back up to re-read a previous section (high-signal attention)
Interaction delay after content	0.07	Time between finishing content and next action (longer = processing/thinking)

Attention vs. Engagement

These two scores are related but capture different dimensions of user behavior:

Dimension	Engagement	Attention
What it measures	Breadth and variety of interaction	Depth and focus of content consumption
High score means	Clicking, scrolling, navigating actively	Reading carefully, pausing to think, re-reading
Low score means	Passive or minimal interaction	Skimming, distracted, multi-tasking
Best use case	E-commerce, product exploration	Content sites, documentation, long-form articles

The Four Attention Archetypes

1. The Deep Reader

High Attention + High Engagement

Thoroughly consuming content and interacting with it. Your ideal audience for long-form content, documentation, and educational material. Action: serve more depth — related articles, downloadable guides, newsletter signup.

2. The Speed Scanner

Low Attention + High Engagement

Clicking around actively but not reading deeply. Looking for a specific answer or comparing options quickly. Action: improve scannability — better headings, summary boxes, table of contents.

3. The Passive Absorber

High Attention + Low Engagement

Reading carefully but not clicking or interacting. May be on mobile, may be a first-time visitor evaluating quality. Action: gentle engagement prompts — inline polls, expandable sections, subtle CTAs.

4. The Distracted Visitor

Low Attention + Low Engagement

Neither reading nor interacting meaningfully. Background tab, arrived accidentally, or lost interest. Action: re-engagement nudge or accept natural exit.

How Momentum, Entropy, and Attention Interact

These three signals form a diagnostic triad that reveals session quality from complementary angles:

Combination	Interpretation	Action
High Momentum + Low Entropy + High Attention	Ideal session: focused, purposeful, absorbing content	Clear path to conversion
High Momentum + High Entropy + Low Attention	Bot-like: fast but random, not reading	Flag for bot review
Low Momentum + Low Entropy + High Attention	Deep researcher: slow but focused, studying one area	Provide depth, comparison tools
Low Momentum + High Entropy + Low Attention	Completely lost: stuck, confused, clicking randomly	Proactive help, exit survey

Session momentum tells you the speed, navigation entropy tells you the order, and attention tells you the depth. Together, they give you a three-dimensional view of session quality that no single metric can provide.

Configuration & Tuning

Model weights and thresholds are tunable per site, so momentum, entropy, and attention scoring can be calibrated to your traffic and page templates rather than left at one-size-fits-all defaults.