Migrate From Adobe

Amplitude offers features, customization options, and scalability for data-driven decision making. This guide explains the process, best practices, and key factors to consider as you transition your product analytics stack.

Migration goals

This guide provides insights into the following areas as you plan your migration:

Data continuity and accuracy

• Ensure a smooth transition with minimal disruption to continuity.
• Guarantee the accuracy and consistency of analytics data in Amplitude.

Efficient configuration and customization

• Replicate the custom configurations and custom reports you have in Adobe Analytics.
• Customize Amplitude to align with your organization's specific reporting needs and business requirements.

User adoption and training

• Provide training on Amplitude to ensure a smooth transition for end-users.
• Provide clear communication to address user concerns and foster user adoption.

Documentation and knowledge transfer

• Document the migration process, including configuration and troubleshooting procedures.
• Transfer knowledge to internal teams responsible for maintaining and using Amplitude.

Compliance and governance

• Ensure compliance with data governance policies and regulatory requirements.
• Review and update privacy and consent policies to align with organizational policies.

Integration

• Enable integration with other tools and platforms that your organization uses.
• Validate and optimize the data flows between Amplitude and other business systems.

Differences in data models and top metrics

Adobe Analytics and Amplitude have different approaches to data modeling and tracking user interactions. Amplitude's data model focuses on events and properties. Adobe Analytics has different configurable data types like "hits" and custom metrics.

• Event Tracking
  • Amplitude:
    • Uses a flexible, event-centric data model.
    • Enables dynamic event tracking without predefined configuration.
    • Supports tracking of user interactions, custom events, and properties.
  • Adobe:
    • Uses page views and custom events to track user interactions.
    • Pre-defines events that require configuration in the Adobe Analytics user interface.
    • Has a more complex creation process for custom events.
• Properties
  • Amplitude:
    • Offers more flexibility with event properties.
    • Captures properties dynamically with events.
    • Allows richer, more dynamic segmentation of user data.
  • Adobe:
    • Relies on eVars and props to capture extra information about events.
    • Requires variable configuration before users can create queries with metrics.
• User identification
  • Amplitude:
    • Uses a user-centric model.
    • Tracks users with an identified user ID.
    • Supports direct user identification and association with events.
  • Adobe: Uses the concept of a visitor to track users across sessions.
• Integrations and API
  • Amplitude:
    • Offers more flexibility with event properties.
    • Captures properties dynamically with events.
    • Allows richer, more dynamic segmentation of user data.
  • Adobe: Provides an API for custom data integrations.

Top metrics

Amplitude and Adobe Analytics use different terminology and structures for metrics, so direct one-to-one mapping may not be possible. The following table compares key metrics in Adobe Analytics with potential equivalents or comparable concepts in Amplitude.

Align on your top metrics and business use cases

Aligning on your top business use cases makes it easier for your users to find useful reports and reduces future maintenance costs.

Before you migrate data, ensure all stakeholders and team members agree on what they want to get from the data. Consider the following:

Top reports and analysis workspaces

To identify the analysis workspaces you use most, use external tools that read your Adobe configuration and provide a report. For example, a third-party Component Editor can return workspace use statistics that show which workspaces and projects are most active.

Use cases and critical metrics to focus on

Work with your top Adobe users and champions to confirm which key reports and KPIs they want to query in Amplitude. Capturing their use cases lets you define the data they need in Amplitude and focus on what matters most. These users build the reports and queries others use, so enabling them as change agents benefits your migration.

For more information, refer to Amplitude's industry-specific best practice guides for sample use cases and questions.

Map your Adobe variables to the Amplitude schema

When you map variables from Adobe Analytics to Amplitude, align the terminology and concepts used in each platform. The following table provides a general guide. The mapping may not be one-to-one, and each platform may collect and report data differently. Specific variable configuration may vary based on the complexity of your analytics implementation.

| Adobe Analytics | Amplitude Analytics | Notes | | ------------------------------- | ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --- | | Page Views | Event: PageView | If you use Amplitude's Browser SDK, you can track Page Views with default event tracking. For users who want a more strategic taxonomy, Amplitude recommends that you identify the correct level of abstraction based on the page hierarchy and site map. | | Success/Custom Events | Event | Success Events map to Amplitude Events. Custom Events in Amplitude are different from Custom Events in Adobe. | | Counter Success Event | Event | | | Currency Success Event | Event | Currency and Numeric Success Events often map to special numeric and currency Event Properties in Amplitude. When you send Revenue/Purchase events to Amplitude, track specific revenue event properties prepended with a $. These event properties relate to the Purchase event. For more information, refer to Track Revenue. | | Numeric Success Event | Event Property | Currency and Numeric Success Events often map to special numeric and currency Event Properties in Amplitude. When you send Revenue/Purchase events to Amplitude, track specific revenue event properties prepended with a $. These event properties relate to the Purchase event. For more information, refer to Track Revenue. | | eVars (Conversion Variables) | Event Properties or User Properties | You can send eVars as either User or Event Properties, depending on the use case. To choose, determine whether the Adobe data variable relates to the user or to events the user performs, and consider how often the values change. User property values persist to subsequent events like eVars, while event property values do not. | | Props (Traffic Variables) | Event Properties | | | | Visit | Session | | | | Visitor ID | User ID | | | | Visitor (Cross-Device Tracking) | Amplitude ID | Amplitude ID is an ID that's used to identify a particular user across multiple User and/or Device IDs | | Conversion Variables | Event Properties, Funnels | | | Segments | Cohorts, Event Segmentation | | | | Instances | Count | | | | Unique Visitors | User ID Count | | | | Pathing | Funnel Analysis, Journeys | | | | Time Parting | Time-based Analysis, Custom Session Definition | | |

After you understand how Amplitude collects data, the next step is to map your current Adobe Analytics variables to Amplitude variables. Use a standard spreadsheet. Most Adobe Analytics customers have a Solution Design Reference (SDR) that lists all Success Events, eVars, and sProps. The SDR spreadsheet can map existing Adobe Analytics variables to Amplitude variables.

To complete this exercise, add an extra column to each SDR tab and add the Amplitude event or property next to each existing Adobe Analytics variable you want to keep. Adobe Analytics Success Events map to Amplitude properties, and Adobe Analytics eVars and sProps also map to Amplitude properties.

As you map each Amplitude property in the spreadsheet, decide whether the property is an Event Property or a User Property.

Track real-time data with Amplitude

After you translate your Adobe schema into Amplitude's required data structure, create a tracking plan document that outlines the events and properties to track, why you track them, and where you track them.

To create your Tracking Plan, go to the Data tab in your organization. If you instrument with Amplitude SDKs, Amplitude recommends the Ampli Wrapper, a lightweight wrapper for the Amplitude SDK that provides type safety, supports linting, and enables features like input validation. The Ampli CLI works with the Ampli wrapper to bring a tracking library into your project.

Select the data source and implementation method

After you decide which data elements to collect in Amplitude and create your Tracking Plan, set up your Source and begin sending data into Amplitude.

Data collection is one of the most critical steps in any analytics program. Digital analytics products must consistently and accurately collect data as customers interact with digital properties. Most organizations have built a data collection layer that pushes data elements from websites and mobile apps to digital analytics products. An intermediary often sits between the data layer and the digital analytics product to map the raw data elements into data variables.

This intermediary could be a Software Development Kit (SDK), JavaScript code, an Application Programming Interface (API), a Customer Data Platform (CDP), or a tag management system. Your organization likely has data collection tools in place for your existing Adobe Analytics implementation. You can often reuse those tools to send data to Amplitude.

Amplitude provides many sources to help you collect and send data.

Client-side sources

Use client-side sources in apps that users run on their own devices, such as mobile, web browser, and desktop apps. Code runs on the user's device.

Amplitude's client-side sources include these SDKs:

• Web: Browser, Marketing Analytics Browser, React Native
• Mobile: Android, iOS, Unity Plugin, Flutter, React Native
• Game engine: Unity Plugin, Unreal

Server-side sources

Use server-side sources in secure, multi-user environments like web servers and services you run on your own servers. Code runs on the server.

Amplitude's server-side sources include these SDKs and APIs:

• HTTP API
• Node.js SDK
• Go SDK
• Python SDK
• Java SDK

Third-party sources

For web-based data collection, you may have a data layer that works with a tag management system. Popular tag management systems used by Adobe Analytics users include Adobe Launch, Tealium, and Google Tag Manager.

Amplitude has pre-built integrations with these tag management systems. These integrations let you reuse your organization's existing data layer work to send data to Amplitude. Update existing tag management system rules to send data to Amplitude instead of Adobe Analytics.

Adobe Launch

If your organization uses Adobe Launch (Adobe's tag management system) to populate Adobe Analytics data, you can use the Amplitude Adobe Launch extension to send data to Amplitude. The extension is a wrapper for the Amplitude JavaScript SDK that lets your organization reuse the existing Adobe Launch data layer to send data to Amplitude.

Tealium

Amplitude integrates with Tealium IQ, Tealium's enterprise tag management service.

Tealium IQ is a universal JavaScript library that creates a universal data object (UDO) for all elements of a page. Tealium sends this data to the data layer first, then you can forward it to third-party vendors, including Amplitude.

You can integrate Tealium iQ with your website in two ways: use Tealium's tag manager or their JavaScript library. For setup instructions, refer to Integrate Tealium with Amplitude.

Google Tag Manager

Amplitude provides Analytics Google Tag Manager templates that collect data and let developers set up event tracking in their applications. These pre-configured templates streamline tracking tag deployment and reduce the time needed to set up event tracking.

Segment

Amplitude offers two methods to integrate with Segment:

• Install Amplitude's SDKs and send data directly to Amplitude through a client-side bundled integration.
• Set up a Segment destination and connect it with a Segment source.

For more information, refer to Migrating from Segment to Amplitude.

mParticle

For more information, refer to mParticle's integration with Amplitude documentation.

Send data downstream to destinations

Use Amplitude Destinations to send your data to third-party platforms. Destinations let you share data generated in Amplitude with other tools and stakeholders.

Backfill historical data

When you migrate from Adobe Analytics, Amplitude recommends that you track only new data going forward.

If you need to send historical Adobe data, Amplitude recommends the following:

• Determine whether historical data is critical to answer your key business questions and metrics. Confirm the source where you'll store historical data after Adobe is sunset. If possible, export the data to a warehouse rather than to Amplitude first.

• Key identifiers, data structures, and user definitions can differ between Adobe Analytics and Amplitude. Because Adobe unique identifiers are complex, align on the logic for the main identifier for your unique visitors. Data model differences can cause expected discrepancies on certain metrics, so align on an acceptable percentage of discrepancies.

• If you need to analyze historical data, confirm the specific events and properties you consider critical. Migrating the full historical dataset takes considerable time, so rank the events and properties your users are most likely to query in Amplitude.

• To prevent identity management issues caused by data model differences, backfill historical data into separate projects. If the data exists in a separate project, you may not be able to analyze trends across certain time periods.

• When historical data is essential, Amplitude recommends limiting backfill to two years of data, with the cutoff usually set to the last month before the full dataset flows into Amplitude. For example, if you plan to start tracking data in your Production project on June 1, your backfilled dataset should end no later than May 31.

Refer to the Data Backfill Guide for more instructions on backfilling data into Amplitude using the Batch Event Upload API.

Migrate historical data to Amplitude

To migrate historical data from Adobe to Amplitude:

1. Export your historical data to your data warehouse so you have a record of your Adobe Analytics data. After export, transform the data warehouse tables into the event and property models that Amplitude expects.
   1. After your historical data is in a warehouse, use Amplitude's Data Warehouse sources or the Batch Event Upload API to import the reformatted data into Amplitude. Refer to the Data Backfill Guide for detailed instructions on backfilling data using the Batch Event Upload API.
   2. If your historical data is in an Amazon S3 bucket, use Amplitude's Amazon S3 import to backfill large amounts of data.
2. If your historical data is in a CDP, check whether the CDP has a historical import feature. For example, Segment's Replay feature can backfill historical data if it's part of your organization's plan.
3. If you need to migrate data directly from Adobe Analytics through Adobe's Data Feeds feature, contact your Amplitude representative.

Verify your data collection

After you set up your Source and complete instrumentation, verify that data is flowing into Amplitude and validate its quality. Follow these best practices as you send data to Amplitude:

• Always test your instrumentation: Amplitude recommends a testing project for every production project in your organization. A testing project gives you a reliable way to test instrumentation before you send production data to Amplitude.
• Amplitude can't retroactively change historical data: If your instrumentation is wrong, you can't clean up the data you collect later. Follow the steps below to QA your event data in Amplitude.

Data validation is a critical step in instrumentation. Amplitude lets you validate event data with the following tools:

• Ingestion Debugger
• User Lookup
• Event Explorer Chrome extension

Ingestion debugger

Use the Ingestion Debugger in Amplitude to check requests, event and identify counts, and throttled users or devices:

1. Log in to Amplitude.
2. Select Data in the top nav bar, then select Source from the left nav bar.
3. Navigate to the Ingestion Debugger tab.

The Ingestion Debugger has three charts that show successful requests, event and identify counts, and error requests for the endpoints you specify. You can specify a time range of either one hour or one week.

Below the Ingestion Debugger is the list of throttled users and devices, including users and device IDs throttled in the last 30 minutes, and a list of silenced device IDs.

User lookup

After you instrument your events, manually send some of those events from your own device. Then follow these steps:

1. Navigate to the Users & Sessions tab in the top nav bar of Amplitude.
2. Navigate to the User tab to view user-level details rather than account-level details.
3. Search by user ID, device ID, Amplitude ID, or user property values.

After you find your user profile, scroll down to the Event Stream section. The event stream displays a user's full event history, grouped by session. The most recent activity appears at the top, and events populate the stream in ten seconds to one minute.

When you select an event, User Lookup shows detailed information about that event, including the user property and event property values at the time of the event.

Because the event stream updates in real time, you can use it to confirm new events are captured correctly, or to troubleshoot instrumentation errors. For example, if you trigger an event one time but the event stream consistently displays two instances, the instrumentation may have an error.

Select Raw to see the raw event data in JSON format.

Event explorer

The Amplitude Event Explorer is a Google Chrome extension that helps you examine and debug your Amplitude Browser SDK instrumentation as you interact with your product. The extension captures each Amplitude event you trigger and displays it in the extension popup.

The extension supports Browser SDK and device-mode/client-side CDP/tag manager implementations.

In the Event Explorer, the Events tab shows detailed insights into the parameters of each event you trigger on your website, including user_id, device_id, event_properties, and user_properties.

Migrate users and replicate reports

After production data flows into the Amplitude project, create accounts for users and begin replicating reports and dashboards.

To create Amplitude users, reference the Adobe Analytics user logs to identify which users most often accessed Adobe Analytics. You can create these users in your organization's settings in Amplitude.

If essential reports or dashboards exist in Adobe Analytics, replicate them in Amplitude and share them with the same users who had access in Adobe Analytics. The third-party Component Manager tool can extract this information. The tool also shows popular Adobe Analytics segments and Calculated Metrics that you may want to replicate in Amplitude.

The following charts are the ones users most often replicate in Amplitude:

• Data Tables: Most like Adobe Analysis Workspace. Supports multi-dimensional analysis with metrics, events, and properties.
• Funnel Chart: Most like Adobe's Funnel Visualization Report. Measures conversion rates.
• Journeys: Analyzes the customer journey and common paths users take. Most like Multi-Channel Funnel reports.
• User Sessions: Analyzes session data ("Visits").
• Metrics: Define and save reusable analysis objects and custom metrics.