Adobe Analytics Setup & Implementation

Adobe Analytics is an enterprise analytics platform that lives inside the Adobe Experience Platform ecosystem. Unlike Google Analytics, where you drop a tag and start collecting data, Adobe Analytics requires deliberate upfront architecture -- report suite design, eVar/prop allocation, XDM schema mapping, and a publishing workflow through Adobe Launch (Tags). A poorly planned implementation creates a report suite filled with unmapped variables, conflicting eVar expirations, and data that cannot be retroactively fixed. The cost of getting it wrong is months of unusable data because Adobe Analytics does not let you reprocess historical hits.

Why Proper Implementation Matters

You Cannot Fix Historical Data

This is the single most important thing to understand about Adobe Analytics:

• eVar misconfigurations are permanent: If you set eVar5 to capture "product category" with Visit expiration, then realize you needed Hit expiration, all historical data for eVar5 is wrong and cannot be corrected
• Deleted report suite data is gone: There is no BigQuery-style raw data export by default (unless you configure Data Feeds or Customer Journey Analytics)
• Processing rules are forward-only: Rules that clean or map data only apply to new hits, not historical ones
• Prop/eVar allocation conflicts: Two teams mapping different data to the same variable creates permanent data corruption in that dimension

Solution Design Reference is Non-Negotiable

Before writing a single line of tracking code, you need a Solution Design Reference (SDR) -- a spreadsheet that maps every business requirement to a specific Adobe Analytics variable:

The SDR is the contract between business stakeholders and the implementation team. Without it, you are guessing.

Web SDK vs. AppMeasurement Decision

Adobe offers two implementation paths:

Web SDK (alloy.js) + Edge Network (recommended for new implementations):

• Sends data to Adobe Experience Platform Edge Network
• Data is mapped via XDM schema to Adobe Analytics, Target, Audience Manager simultaneously
• Future-proof: required for Customer Journey Analytics (CJA)
• Supports server-side forwarding natively
• Smaller JavaScript footprint

AppMeasurement.js (legacy):

• Sends data directly to Adobe Analytics collection servers
• Uses context data variables or direct s.eVar/s.prop assignment
• Mature and well-documented but being deprecated in favor of Web SDK
• Does not support CJA without additional data pipeline

Decision matrix:

• New implementation: Use Web SDK
• Existing AppMeasurement with no CJA plans: Keep AppMeasurement, migrate later
• Existing AppMeasurement with CJA plans: Migrate to Web SDK now

Pre-Implementation Planning

Access and Permissions

Adobe Admin Console (adminconsole.adobe.com):

1. Confirm you have Product Admin access for Adobe Analytics
2. Verify access to the correct Product Profiles
3. Ensure you have access to Adobe Experience Platform Data Collection (Launch/Tags)

Required Roles:

Report Suite Configuration:

1. In Adobe Analytics, go to Admin > Report Suites
2. Create or identify report suites:
   • Development: For testing (lower data retention OK)
   • Staging: QA validation before production
   • Production: Live data collection
3. Configure each report suite:
   • General Settings: Currency, time zone, base URL
   • Traffic Variables (props): Allocate and name
   • Conversion Variables (eVars): Allocate, name, set expiration and allocation
   • Success Events: Define and name
   • Processing Rules: Set up data mapping rules

XDM Schema Design (Web SDK)

If using Web SDK, design your XDM schema before implementation:

1. In Adobe Experience Platform, go to Schemas
2. Create a new schema based on "XDM ExperienceEvent"
3. Add field groups:
   • Web Details: Page URL, page name, referrer
   • Commerce: Product views, cart events, purchases
   • Environment: Browser, device, OS
   • Identity: ECID, custom identifiers
4. Map XDM fields to Adobe Analytics variables using a Datastream:
   • In Datastreams, create a new datastream
   • Add Adobe Analytics as a service
   • Configure report suite ID
   • Map XDM fields to eVars, props, and events

Identity Strategy

ECID (Experience Cloud ID):

• Automatically generated by the Visitor ID Service (part of Web SDK or separate ECID extension)
• Serves as the primary identifier across all Adobe solutions
• Stored in an AMCV_ cookie with your Organization ID
• First-party CNAME implementation recommended for longer cookie duration

Cross-Device Identity:

• For authenticated users, set identityMap with a hashed login ID
• ECID provides cross-solution stitching; custom ID provides cross-device stitching
• Consider the Customer Journey Analytics identity stitching model if migrating to CJA

Implementation Walkthrough

Step 1: Set Up Adobe Launch (Tags)

1. Go to Adobe Experience Platform Data Collection at experience.adobe.com

2. Navigate to Tags > Properties

3. Create a new property (or select existing):

   • Name: "Your Website - Production"
   • Platform: Web
   • Domain: yoursite.com

4. Configure environments:

   • Development: For local testing
   • Staging: For QA validation
   • Production: For live site

5. Install required extensions:

For Web SDK approach:

• Adobe Experience Platform Web SDK (alloy.js)
• Configure with your Datastream ID and Organization ID

For AppMeasurement approach:

• Adobe Analytics
• Experience Cloud ID Service

Step 2: Configure Data Elements

Data elements in Launch map your website data to tracking variables.

Web SDK Data Elements:

// Data Element: Page Name (XDM)
// Type: Custom Code
return document.title || window.location.pathname;

// Data Element: Product Category (XDM)
// Type: Data Layer
// Path: digitalData.product.category

// Data Element: User Email Hash (for identity)
// Type: Custom Code
if (window.digitalData && window.digitalData.user && window.digitalData.user.email) {
  // SHA-256 hash the email
  const encoder = new TextEncoder();
  const data = encoder.encode(window.digitalData.user.email.toLowerCase().trim());
  return crypto.subtle.digest('SHA-256', data).then(buffer => {
    return Array.from(new Uint8Array(buffer)).map(b => b.toString(16).padStart(2, '0')).join('');
  });
}
return undefined;

AppMeasurement Data Elements:

// Data Element: Page Name
// Type: JavaScript Variable
// Path: digitalData.page.pageName

// Data Element: Product String
// Type: Custom Code
// Adobe product string format: Category;ProductID;Qty;Price
var products = window.digitalData.cart.items.map(function(item) {
  return item.category + ';' + item.sku + ';' + item.quantity + ';' + item.price;
}).join(',');
return products;

Step 3: Create Tracking Rules

Page View Rule (Web SDK):

// Rule: Send Page View
// Event: Core - Library Loaded (Page Top)
// Action: Adobe Experience Platform Web SDK - Send Event

// XDM Object:
{
  "xdm": {
    "eventType": "web.webpagedetails.pageViews",
    "web": {
      "webPageDetails": {
        "pageViews": { "value": 1 },
        "name": "{{Data Element - Page Name}}",
        "URL": window.location.href
      }
    },
    "commerce": {},
    "productListItems": []
  }
}

Purchase Event Rule (Web SDK):

// Rule: Track Purchase
// Event: Custom Event - "purchase"
// Action: Adobe Experience Platform Web SDK - Send Event

{
  "xdm": {
    "eventType": "commerce.purchases",
    "commerce": {
      "purchases": { "value": 1 },
      "order": {
        "purchaseID": "{{DL - Order ID}}",
        "priceTotal": {{DL - Order Total}},
        "currencyCode": "USD"
      }
    },
    "productListItems": "{{DL - Product Array}}"
  }
}

Page View Rule (AppMeasurement):

// Rule: Set Analytics Variables
// Event: Core - Library Loaded (Page Top)
// Action: Adobe Analytics - Set Variables

s.pageName = "{{Data Element - Page Name}}";
s.channel = "{{Data Element - Site Section}}";
s.prop3 = "{{Data Element - Page Template}}";
s.eVar1 = "{{Data Element - Product Category}}";
s.events = "event1";  // Page view event

// Action: Adobe Analytics - Send Beacon
// Tracking Type: Page View (s.t())

Custom Link Tracking (AppMeasurement):

// Rule: Track Add to Cart
// Event: Custom Event - "addToCart"
// Action: Adobe Analytics - Set Variables

s.linkTrackVars = "products,events,eVar1";
s.linkTrackEvents = "scAdd,event10";
s.products = "{{Data Element - Product String}}";
s.events = "scAdd,event10";
s.eVar1 = "{{Data Element - Product Category}}";

// Action: Adobe Analytics - Send Beacon
// Tracking Type: Custom Link (s.tl())
// Link Name: "Add to Cart"

Step 4: Configure Processing Rules

In Adobe Analytics Admin:

1. Go to Admin > Report Suites > Select suite > Edit Settings > General > Processing Rules
2. Create rules to map context data to Analytics variables:

Step 5: Deploy and Promote

Adobe Launch uses a three-environment publishing workflow:

1. Build in Development:

   • Create a library in Launch
   • Add all rules, data elements, and extensions
   • Build to Development environment

2. Test in Staging:

   • Use Adobe Experience Platform Debugger to validate hits
   • Promote library to Staging
   • Run QA test plan

3. Publish to Production:

   • After QA approval, promote to Production
   • Schedule during low-traffic period
   • Monitor real-time reports for 30 minutes after publish

Launch Embed Codes:

<!-- Development -->
<script src="https://assets.adobedtm.com/YOUR_ORG/YOUR_PROPERTY/launch-DEV_ID.min.js" async></script>

<!-- Staging -->
<script src="https://assets.adobedtm.com/YOUR_ORG/YOUR_PROPERTY/launch-STG_ID.min.js" async></script>

<!-- Production -->
<script src="https://assets.adobedtm.com/YOUR_ORG/YOUR_PROPERTY/launch-PROD_ID.min.js" async></script>

Verification and QA

Adobe Experience Platform Debugger

1. Install the Chrome extension
2. Navigate to your website
3. Open the debugger and check:

For Web SDK:

• Edge Network tab: Verify events are sent to Edge
• XDM tab: Inspect the full XDM payload structure
• Analytics tab: Confirm report suite ID and variable mapping
• Identity tab: Verify ECID is present

For AppMeasurement:

• Analytics tab: See all variables in the beacon
• Verify report suite ID(s)
• Check eVar values, prop values, events
• Confirm product string format (if ecommerce)
• Validate tracking server

Analysis Workspace Validation

1. In Adobe Analytics, open Analysis Workspace
2. Create a new project
3. For each variable in your SDR, create a freeform table:
   • Drag the dimension (eVar/prop) to the table
   • Verify expected values appear
   • Check for unexpected values (data quality issues)
4. Create a "QA Dashboard" with key metrics:
   • Page views by page name
   • Conversion events by type
   • Product views and purchases
   • Revenue by product category

Real-Time Report

1. Go to Reports > Real-Time
2. Configure to show key events
3. Trigger test events on the website
4. Verify events appear within 60 seconds

Common Issues

Deployment Artifacts

• Solution Design Reference (SDR): Complete eVar/prop/event allocation spreadsheet with owners
• Launch property URLs: Embed codes and library versions for dev, staging, production
• XDM schema documentation: Field mappings from XDM to Adobe Analytics variables (Web SDK)
• Processing rules documentation: All active rules with descriptions and owners
• Identity strategy: ECID configuration, CNAME setup, cross-device identity plan
• Report suite settings: Configuration export for each report suite
• Publishing workflow: Approval chain for promoting libraries between environments
• Data layer specification: Expected data layer structure with field definitions

Linked Runbooks

• Install or Embed the Tag or SDK -- Launch embed code deployment and Web SDK initialization
• Event Tracking -- Custom event and commerce tracking configuration
• Data Layer Setup -- Data layer structure for Adobe Analytics
• Cross-Domain Tracking -- ECID visitor stitching across domains
• Server-Side vs Client-Side -- Web SDK Edge Network vs. AppMeasurement direct collection

Change Log and Owners

• Track who owns the Solution Design Reference and who approves variable allocation changes
• Document Launch library publishes with version IDs, dates, and approvers
• Maintain a list of pending migrations from AppMeasurement to Web SDK
• Record processing rule additions with dates and descriptions
• Review quarterly: eVar utilization, unused variables, data quality metrics