Measurement and tracking review

The implementation collects what the tools allow and decides how to use it later.

Next check: Choose one critical report and trace which decisions it supports and which fields it actually uses.

A tracking plan exists, but it mixes current requirements with inherited fields.

Next check: Tag every field with its consumer, purpose, and last-use date before extending the plan.

Events and variables answer documented questions and have known consumers.

Next check: Check that every new request declares the decision, consumer, and acceptance criterion.

Collection is reviewed and retired when questions, products, or consumers change.

Next check: Maintain a periodic usage review and retire contracts with no consumer before adding new ones.

Each surface sends events according to the needs of its primary tool.

Next check: Compare one shared journey across web, app, and backend and record differences in name, type, and timing.

A shared taxonomy exists, but exceptions are neither versioned nor retired.

Next check: Inventory active exceptions and decide which enter the contract, remain isolated, or are removed.

Events have a defined schema, meaning, examples, and owners.

Next check: Validate contracts during development and ingestion, not only through later manual review.

Contracts are versioned, validated automatically, and maintain known compatibility.

Next check: Test incompatible changes in a controlled environment and document affected consumers before release.

Each tool decides which identifier to use and when to persist it.

Next check: Map the identifier journey before and after login and locate where values are replaced or duplicated.

Identity rules exist, but do not cover every session, device, or consent transition.

Next check: Test login, logout, rejection, and device transitions with reproducible cases.

Each identifier has a documented source, persistence rule, and use for every surface.

Next check: Add tests that detect unexpected identity changes before releasing new versions.

Identity transitions are tested and their effects are observed in downstream consumers.

Next check: Maintain alerts for fragmentation, duplication, and context loss in critical journeys.

Changes are published directly in each tool and documented afterwards.

Next check: Choose the latest change and reconstruct who approved, tested, published, and documented it.

Environments and approvals exist, but urgent exceptions bypass the process.

Next check: Review recent urgent changes and add a mandatory closure step that updates tests and documentation.

Request, specification, testing, and release form one traceable flow.

Next check: Check that rollback, retirement, and ownership also form part of every change.

Changes are contract-tested and can be retired without depending on their author.

Next check: Periodically run a controlled rollback or retirement to validate the complete procedure.

Failures are discovered when a report or campaign no longer reconciles.

Next check: Select three critical events and define expected volume, required fields, and a duplication signal.

Manual checks run before release, but there is little monitoring after the change.

Next check: Add a post-release check for volume, schema, and affected consumers.

Critical events have tests, thresholds, and investigation owners.

Next check: Simulate loss, duplication, and type changes to confirm alerts are actionable.

Quality is observed from collection through to relevant reports and activations.

Next check: Periodically review false positives, coverage, and alert detection times.

Each destination receives its own variant and transformations live inside connectors.

Next check: Compare one event at source, in the server-side layer, and in two destinations to locate implicit transformations.

Primary routes are documented, but deduplication and errors do not follow a shared rule.

Next check: Define deduplication keys, retry policy, and an owner for every critical route.

Transformations, filters, consent, and deduplication are visible and testable by destination.

Next check: Add contract tests that confirm what leaves, what is dropped, and what is retried.

Each route has traceability, alerts, and reconciliation with the final consumer.

Next check: Test partial failures and confirm retries and deduplication do not alter final metrics.