What is edge-computed behavioral intelligence?

Edge-computed behavioral intelligence processes visitor behavior at the CDN edge — Cloudflare's global network — rather than in a centralized data center. This enables real-time scoring of 26 behavioral models in under 3ms, fast enough to personalize the current page load.

How many behavioral models does ClickStream use?

ClickStream runs 26 behavioral scoring models at the edge, covering intent detection, frustration scoring, engagement depth, churn prediction, LTV estimation, purchase timing, content affinity, bot detection, anomaly detection, and more. Each model produces a normalized score updated in real time.

What is the ClickStream Behavioral Model Series?

The Behavioral Model Series is a 13-part technical deep-dive covering each of ClickStream's 26 edge-computed scoring models. Each installment explains the behavioral signals analyzed, the scoring methodology, and practical applications for marketing, UX, and fraud prevention.

Behavioral Model Deep-Dives: Edge-Computed User Intelligence

What You'll See in the Dashboard

In the Intelligence tab at einstein.clickstream.com, every active visitor has 26 real-time behavioral scores. Each score is a 0–100 value with color coding: green, amber, red. Click any score card to see its trend chart, contributing signals, and configured alert thresholds. This series explains what each score measures, what it means for your business, and how it works under the hood.

Why Behavioral Scoring at the Edge?

Traditional analytics tools collect events and ship them to a server for batch processing. By the time insights emerge, the user is long gone. ClickStream takes a fundamentally different approach: every behavioral model runs inside a Cloudflare Worker, scoring user behavior in real time at the nearest edge node -- typically within 50ms of the triggering event.

This architecture yields three critical advantages:

Latency: Scores are available before the next page render, enabling real-time personalization and intervention.
Privacy: Raw behavioral signals never leave the edge. Only computed scores are stored, minimizing PII exposure.
Cost: Edge compute is dramatically cheaper than maintaining GPU clusters for real-time ML inference.

The 26 Behavioral Models

ClickStream computes 26 distinct behavioral scores for every active session. Each score is a normalized 0–100 value, updated incrementally as new events arrive. Together, they form a comprehensive behavioral signature that powers personalization, alerting, and predictive analytics.

#	Model	What It Measures	Series Part
1	Intent Score	Purchase/conversion likelihood based on navigation patterns	Part 1
2	Frustration Score	User friction signals (rage clicks, dead clicks, error encounters)	Part 1
3	Engagement Score	Depth and quality of interaction with content	Part 1
4	Value Estimator	Predicted monetary value of the session/visitor	Part 2
5	Anomaly Score	Statistical deviation from normal behavioral patterns	Part 2
6	Confusion Score	Navigation confusion and information-finding difficulty	Part 3
7	Emotional State	Inferred emotional valence from interaction dynamics	Part 3
8	Decision Confidence	How confident the user appears in their purchase decision	Part 4
9	Regret Risk	Likelihood of post-purchase regret or return	Part 4
10	Churn Prediction	Probability of visitor/customer churn	Part 5
11	LTV Score	Predicted lifetime value based on behavioral signals	Part 5
12	Abandonment Score	Real-time cart/form/page abandonment detection	Part 6
13	Purchase Timing	Proximity to purchase decision and urgency signals	Part 6
14	Content Affinity	Topic and content-type preferences	Part 7
15	Form Friction	Field-level form interaction difficulty	Part 7
16	Next Action Prediction	Most likely next user action with confidence score	Part 7
17	Session Momentum	Velocity and direction of user progression through site	Part 8
18	Click Entropy	Randomness/predictability of click patterns	Part 8
19	Attention Score	Tab visibility, scroll engagement, and active focus signals	Part 8
20	Conversion Probability	Real-time likelihood of completing a conversion goal	Part 9
21	Hover Intent	Hover behavior patterns revealing CTA/product interest	Part 9
22	Scroll Depth Intelligence	Scroll regression, content zone engagement, reading patterns	Part 9
23	Price Sensitivity	Comparison shopping behavior, price page revisits, discount seeking	Part 10
24	Loyalty/Return Propensity	Return likelihood based on session patterns and engagement	Part 10
25	Micro-Conversion Score	Completion of intermediate conversion steps	Part 10
26	Bot/Fraud Detection Score	Behavioral biometrics-based bot and fraud detection	Part 10

The Three-Phase Pipeline

Every incoming event flows through a three-phase pipeline before scores are updated. This pipeline is designed for incremental computation -- no event requires rescanning the full session history.

Phase 1: Event Ingestion & Normalization

Raw browser events (clicks, scrolls, mouse movements, form interactions, page transitions) arrive as JSON payloads at the edge worker. The ingestion phase normalizes timestamps, deduplicates rapid-fire events, and enriches each event with session context.

TypeScript

// Phase 1: Event normalization
interface RawEvent {
  type: 'click' | 'scroll' | 'mousemove' | 'keypress' | 'pageview' | 'form' | 'visibility';
  timestamp: number;
  target?: string;        // CSS selector of interacted element
  position?: { x: number; y: number };
  scrollDepth?: number;   // 0-100 percentage
  formField?: string;     // field identifier (never the value)
  pageUrl: string;
  viewport: { width: number; height: number };
}

Phase 2: Feature Extraction

Normalized events are fed into the feature extraction layer, which maintains running statistics and computes derived features. This layer produces a BehavioralFeatures object that serves as input for all 26 models.

TypeScript

interface BehavioralFeatures {
  // Temporal features
  sessionDuration: number;       // ms since session start
  timeSinceLastEvent: number;   // ms idle time
  eventRate: number;             // events per second (rolling 30s window)
  pageViewCount: number;         // total pages viewed
  avgTimeOnPage: number;         // mean dwell time across pages

  // Interaction features
  clickCount: number;
  scrollDepthMax: number;       // deepest scroll across session
  scrollDepthCurrent: number;   // current page scroll depth
  scrollVelocity: number;       // px/s average scroll speed
  mouseVelocity: number;        // px/s average mouse speed
  mouseDistanceTotal: number;   // total mouse travel in px

  // Navigation features
  backButtonCount: number;      // browser back navigations
  revisitedPages: number;       // unique pages visited > 1 time
  navigationPattern: 'linear' | 'exploratory' | 'bouncing' | 'focused';

  // Engagement features
  formFieldsInteracted: number;
  formFieldsCompleted: number;
  tabVisibilityRatio: number;   // % of session with tab visible

  // Error/frustration features
  rageClickCount: number;       // 3+ clicks in 500ms on same element
  deadClickCount: number;       // clicks with no DOM response
  errorEncounters: number;      // JS errors, 4xx/5xx responses
  cursorThrashing: number;      // rapid direction changes per second
}

Phase 3: Model Scoring

The scoring phase takes the BehavioralFeatures object and the current SessionContext, runs all 26 models, and produces the final score set. Each model is a pure function: given the same features and context, it always returns the same scores.

TypeScript

interface SessionContext {
  visitorId: string;
  sessionId: string;
  isReturning: boolean;
  previousSessions: number;
  deviceType: 'desktop' | 'tablet' | 'mobile';
  referrerCategory: 'direct' | 'search' | 'social' | 'email' | 'paid' | 'referral';
  landingPageCategory: string;
  geoRegion: string;
  localHour: number;          // 0-23 in visitor's timezone
}

interface BehavioralScores {
  intentScore: number;           // 0-100
  frustrationScore: number;      // 0-100
  engagementScore: number;       // 0-100
  valueEstimate: number;         // 0-100
  anomalyScore: number;          // 0-100
  confusionScore: number;        // 0-100
  emotionalState: string;        // classified label
  decisionConfidence: number;    // 0-100
  regretRisk: number;            // 0-100
  churnPrediction: number;       // 0-100
  ltvScore: number;              // 0-100
  abandonmentScore: number;      // 0-100
  purchaseTiming: number;        // 0-100
  contentAffinity: Record<string, number>; // category affinities
  formFriction: number;          // 0-100
  nextAction: { action: string; confidence: number };
}

The `clickstream_scores` Dataset Schema

All computed scores are written to the clickstream_scores dataset in your configured data warehouse. This is the single source of truth for all behavioral intelligence and serves as the foundation for downstream analytics, alerts, and ML pipelines.

SQL

CREATE TABLE clickstream_scores (
  -- Identity
  visitor_id        STRING       NOT NULL,
  session_id        STRING       NOT NULL,
  score_timestamp   TIMESTAMP    NOT NULL,
  edge_location     STRING,       -- Cloudflare colo code

  -- Core scores (0-100)
  intent_score          FLOAT64,
  frustration_score     FLOAT64,
  engagement_score      FLOAT64,
  value_estimate        FLOAT64,
  anomaly_score         FLOAT64,
  confusion_score       FLOAT64,
  emotional_state       STRING,
  decision_confidence   FLOAT64,
  regret_risk           FLOAT64,
  churn_prediction      FLOAT64,
  ltv_score             FLOAT64,
  abandonment_score     FLOAT64,
  purchase_timing       FLOAT64,
  content_affinity      JSON,
  form_friction         FLOAT64,
  next_action           STRING,
  next_action_confidence FLOAT64,

  -- Context
  device_type       STRING,
  referrer_category STRING,
  landing_page      STRING,
  geo_region        STRING,
  session_duration  INT64,       -- ms at time of scoring
  page_view_count   INT64,
  event_count       INT64,

  -- Metadata
  model_version     STRING,       -- semver of scoring model
  pipeline_latency  FLOAT64,      -- ms from event to score write
  is_final          BOOLEAN       -- true for end-of-session snapshot
)
PARTITION BY DATE(score_timestamp)
CLUSTER BY visitor_id, session_id;

How Scores Flow Through the System

The pipeline operates as an event-driven loop. Here is the full lifecycle of a single behavioral event:

Browser SDK captures a user interaction (click, scroll, page transition, form field interaction).
Edge Worker receives the event at the nearest Cloudflare PoP (200+ locations globally).
Session State is loaded from Durable Objects -- a persistent, co-located key-value store that holds the current BehavioralFeatures and SessionContext.
Feature Update: The new event updates the running feature counters and statistics.
Model Scoring: All 26 models re-score in parallel using the updated features. Each model is a deterministic function with no external dependencies.
Score Emission: Updated scores are written to the clickstream_scores dataset via batched inserts (every 5 seconds or on significant score changes).
Real-time Actions: If any score crosses a configured threshold, the worker triggers configured actions (webhooks, personalization rules, alert notifications).

The entire pipeline -- from event arrival to score emission -- averages 12ms at the p50 and 47ms at the p99. This is fast enough to modify the response for the current page load.

Design Principles

Several principles guide the design of every model in this series:

Incremental Computation

No model ever requires scanning the full event history. Every score can be updated from the previous score plus the new event. This keeps compute costs O(1) per event regardless of session length.

Weighted Signal Decay

Recent events carry more weight than older ones. Most models use an exponential decay function with a configurable half-life (typically 60–120 seconds). This means a rage-click 30 seconds ago matters more than one from 5 minutes ago.

Normalization to 0–100

All scores are normalized to a 0–100 scale using sigmoid functions calibrated on historical data. This makes scores directly comparable across models and easy to reason about in business rules.

Cross-Model Interaction

Models are not independent -- they inform each other. For example, a high frustration score suppresses the intent score (frustrated users are less likely to convert), while a high engagement score amplifies value estimates. These interactions are documented in each part of the series.

Configurable Thresholds

Every model exposes thresholds that can be tuned per-site. Default thresholds are calibrated on aggregate data across ClickStream deployments, but you can override them for your specific use case.

Series Index

This series is organized into ten parts, each covering two to four closely related models. The groupings reflect how models interact in practice -- understanding them together gives you a much richer picture than treating each in isolation.

Part	Models Covered	Key Topics
Part 1	Intent, Frustration, Engagement	Signal weights, intent categories, 9 frustration signals, tab visibility, 4 behavioral archetypes, e-commerce walkthrough
Part 2	Value Estimator, Anomaly Detection	E-commerce vs SaaS scoring, dual baseline comparison, bot detection formula, false positive mitigation
Part 3	Confusion, Emotional State	7 confusion signals, 4 confusion types, 6 emotional states, mouse dynamics, typing cadence, ethical considerations
Part 4	Decision Confidence, Regret Risk	7 confidence signals, convergence analysis, speed-research mismatch, price sensitivity, intervention strategies
Part 5	Churn Prediction, LTV Score	9 churn signals, SaaS vs e-commerce, 4 LTV tiers, priority matrix with actions, real-time intervention timeline
Part 6	Abandonment, Purchase Timing	8 abandonment signals, exit intent formula, latency breakdown, proximity scoring, urgency classification
Part 7	Content Affinity, Form Friction, Next Action	6 affinity types, 5 friction types, sequential pattern mining, personalization trinity
Part 8	Session Momentum, Click Entropy, Attention Score	Progression velocity, click randomness, tab focus, reading patterns, bot vs human signals
Part 9	Conversion Probability, Hover Intent, Scroll Depth Intelligence	Real-time conversion likelihood, CTA hover patterns, scroll regression, content zone analysis
Part 10	Price Sensitivity, Loyalty, Micro-Conversion, Bot Detection	Comparison shopping, return propensity, funnel micro-steps, behavioral biometrics fraud detection

Prerequisites

This series assumes familiarity with:

Basic statistics (mean, standard deviation, sigmoid functions)
Web analytics concepts (sessions, pageviews, events)
TypeScript/JavaScript (code examples use TypeScript interfaces)
SQL (for dataset schema and query examples)

No machine learning expertise is required. While the models are inspired by ML techniques, they are implemented as deterministic scoring functions that can be reasoned about directly.

Getting Started

Start with Part 1: Intent, Frustration & Engagement to understand the three foundational models, or jump directly to the model group most relevant to your use case using the series navigation above.

Each part is self-contained -- you can read them in any order -- but the cross-model interactions will make more sense if you have read the earlier parts first.

Behavioral Model Deep-Dives: Edge-Computed User Intelligence

What You'll See in the Dashboard

Why Behavioral Scoring at the Edge?

The 26 Behavioral Models

The Three-Phase Pipeline

Phase 1: Event Ingestion & Normalization

Phase 2: Feature Extraction

Phase 3: Model Scoring

The clickstream_scores Dataset Schema

How Scores Flow Through the System

Design Principles

Incremental Computation

Weighted Signal Decay

Normalization to 0–100

Cross-Model Interaction

Configurable Thresholds

Series Index

Prerequisites

Getting Started

26 Scores That Tell You Exactly What Each Visitor Wants

The `clickstream_scores` Dataset Schema