Capabilities Overview

Customer Identity Graph Overview

Engaging the customer in a meaningful way requires a deep understanding of your customer's real-time intent, patterns in their behaviour and the ability to influence customer actions at the moment of highest impact.

Conscia’s Customer Identity Graph provides a unique set of tools for marketing and digital teams that not only provides a 360 view of the customer, it gives complete control over who sees what, when, and where. You can gain deep insights into customer behaviour, create real-time audience segments, manage hyper-personalized experiences and measure the effectiveness of your campaigns with ease and speed. Finally, the Customer Identity Graph is available to your entire MarTech stack as a single, real-time view of the customer.

The Customer Identity Graph comes with the following capabilities:

Create Unified Customer Profiles

• Onboard customer data from custom and legacy applications through MESH APIs, file-based imports and webhooks
• Ingest historical transactional data from legacy and enterprise systems via file-based imports
• Data Cleansing & Transformation via MESH
• Flexible schema for customer profiles
• Resolve Indentities and De-duplication (deterministic and probablistic)
• Persistent Anonymous profiles (with customer consent) C
• Customer Identity Graph and De-duplication
• Individual and account-level profiles for B2B use cases
  

Enrich Profiles

• Create Audience Segments (flat or hierarchical) with an Intuitive GUI
• Audience Builder UI for non-technical users
• Ingest unlimited user traits from data warehouse / enterprise systems
• Compute behavioural, emotional, loyalty traits within Conscia Intel
• Compute journey stages for customer profiles
• AI based Predictive Scores

Cross-Channel Activation (Share profiles with other systems)

• Publish customer profiles to any downstream social media or marketing platform via batch exports or publish operations
• Share customer profiles with other enterprise systems via batch exports, webhooks and publish operations
• Real-time Profile API to access customer information from Web/Mobile or any last mile delivery platform

Analytics and Dashboards

• Customer 360 View
• Audience 360 Dashboard
• Raw Data Export to Data Warehouse, BI Platorms for Advanced Analytics
  

Security and Privacy

• GDPR Compliance
• ISO 27001
• SOC 2 Type 1 - On track for completion in < 6 months
• CCPA Compliance
• Role-based Access Controls
• Granular / Record level permissions
• Secure data access through APIs as well as through Control Center

The Unified Customer Profile

Conscia's Control Center provides a 360 degree view of your customer that includes insights that have been aggregated, computed or predicted based on the real-time interactions and events on every channel.

Conscia can collect information about the customer from any source and it traditionally falls into one of the following categories:

• Profile Data (contact, demographic, privacy, preference, interest, transactional)
• Behavioral / Interaction data (opens, clicks, downloads, views) web pages, marketing campaigns, etc.
• Attitudinal & Assessment (surveys, sentiment, quizzes, calculators, assessment, etc.)

Data is added to Conscia in one of three ways:

• Inbound Integrations with legacy systems and tools that house or collect customer data (CRM, DMP, Preference Center, Forms, E-Commerce, etc.)
• Tracking pixels, URLs, and QR codes
• Manually make changes to one profile or to many through bulk uploads and actions
• Customer APIs

Unify and Resolve

Conscia allows you to create a unified profile of your customer by combining attributes from multiple sources of data. Identity resolution within Conscia allows you to do the following:

• Retain data history (shadow data) so marketers can see the identity resolution history and reactivate shadow data, if needed.
• Build custom identity resolution rules
• Create a Golden Record that all other applications can access
• Use a machine learning model to de-duplicate customer records that maybe sourced from multiple data sources and allows you to train it with parameters that are appropriate based on your data model.

Rich Profile Attributes

Define and calculate customer profile attributes that are needed for your marketing programs.

• Flexible data model allows organizations to:
  • collect and configure profile data that matters to marketers (numeric, date, visual, etc.)
  • Define taxonomical relationships between profiles such as accounts
• Conscia helps marketers enrich profiles with the following types of attributes for activation.
  • Configure custom computed fields that perform aggregations on transaction and event level data, or select default computed fields that come packaged with the product.
  • Calculate behavioural scores including RFM analysis, specifically, Recency, Intensity, Frequency, Maturity, Momentum, Monetary
  • Emotional Scores such as CSAT, Sentiment Score and NPS
  • Audience Segments such as New, Power, Inactive, Dormant, Unscored, At-Risk, Binge, Perusers, Switchers, Habitual Buyers, Satisfied Customer, Advocates
  • Predictive Scores such as Lead Score, Lifetime Value, Churn Potential, Purchase Propensity
  • Journey Stages such as Awareness, Consideration, Conversion, Engagement, Advocacy
  • Rolled-up account profiles
  • Raw behavioural activity and transactions
• Aggregate individual profiles from the same account into an account view

Conscia Intel

Conscia Intel is a key component of Conscia's Customer Data Platform. It is responsible for computing aggregations, analysis, and machine learning on billions of rows of customer data to understand behavioral and psychographic trends.

• Customer analytics (including touchpoint)
• Slice and dice by any customer attribute including calculated / computed fields (propensity, journey stage, etc.)
• AI workbench
• Share schema-less data with other big data platforms such as data lakes

Conscia big data and analytics infrastructure consists of various data processing and storage components that collect, stage, aggregate, predict and recognize behavioural patterns and support real-time access and analytics. These include S3 compatible object storage, Hive and Presto for big data analytics and processing and proprietary machine learning algorithms.

Capturing User Interactions

Intel offers a Track API to collect user generated data such as clickstreams, viewstreams, and activity streams. This data is often produced as a result of users interacting with digital products such as mobile applications, websites, etc. This allows you to measure user engagement, track A/B test data for product releases, and generate user traits based on behavioural patterns.

Real-time Events

Documentation Coming Soon.

Offline Transactions

Offline events can be captured in one of the following three ways:

• Upload a batch file with offline events
• Stream events asynchronously into Conscia Intel

Detailed Documentation Coming Soon

Calculating Computed Fields

Intel can compute user profile attributes such as customer's lifetime value, lifetime orders, category affinity, etc, as well as campaign and content level analytics such as click through rates, conversions, most viewed by segment, etc. These computed fields are calculated using queries issued directly to the big data store containing the raw events such as purchase transactions, views, clicks, etc.

Metric type	Data Type	Computation Template	Parameters Required	Filter Parameters	Sample Computations
Time Since Last	Number	{Time Since} Last {Event Name}	Event Name, Time Format	Time Window, Context Field	Days since last {Purchase, Add to Cart, Add to Wish List, Visit, Page View, etc}
Time Since First	Number	{Time Since} First {Event Name}	Event Name, Time Format	Time Window, Context Field	Days since first {Purchase, Add to Cart, Add to Wish List, Visit, Page View, etc}
Count	Number	{Count of Events} of {Event Name}	Event Name	Time Window, Context Field	Number of {purchases, page views, etc}
Count, Grouped	Array of Key/Value Pairs	{Count of Events} of {Event Name}, grouped by {Context Field}	Event Name, Group By Context Field	Time Window, Context Field	Number of {purchases, page views, etc} by {Channel, Device, Location, Browser Type, Product Category, Brand}
Context from Last	String	{Context Field} for Last/First {Event Name}	Event Name, Context Field	Time Window, Context Field	{Product Category, Brand, Price, Device, Location} of Last {Product Purchased, Product Viewed, etc}
Context from First	String	{Context Field } for Last/First {Event Name}	Event Name, Context Field	Time Window, Context Field	{Product Category, Brand, Price, Device, Location} of First {Product Purchased, Product Viewed, etc}
Unique List with Counts	Array of Key/Value Pairs	{Unique List} {Context Field}{Sorted by}	Context Field, Sort Type	Time Window, Context Field	Unique List of {Channels, Device, Locations, Brands, Topics, etc}
Aggregation (Sum/Min/Max/Avg)	Number	{Aggregation} for {Event Name}	Aggregation Type, Event Name	Time Window, Context Field	Total Spend, Average Spend
Aggregation, Duration	Number	{Aggregation} Duration of {Event Name}	Event Name, Context Fields		Total Minutes Watched, Minimum Minutes Watched, Average Minutes Watched
Aggregation (Sum/Min/Max/Avg), Grouped	Array of Key/Value Pairs	{Aggregation} for {Event Name} grouped by {Context Field }	Event Name, Context Fields	Time Window, Context Field	Total Revenue by Brand, Category, Device, etc

Scheduling Computations

During onboarding, the computation schedule is established. For some use cases, it may make sense to run computations multiple times per day while in other cases, once a day may be sufficient. Please note that the total compute power required for your instance will be based on the number of compute operations and the storage requirements.

Number of Compute Operations = Number of Unique Computed Fields x Number of Times Calculated

Generating Predictive Scores

Conscia provides configurable Machine Learning models to create different types of predictive scores such as customer's propensity - how likely or unlikely people are to take an action, such as purchase, or churn. This allows our customers to create optimized offers, promotions, discounts and more based on thousands of behavioral data points in no time.

For more information on this capability, please speak with your Account Representative.

Evaluating Journey Stages

Conscia allows Marketers to define and compute Journey Stages via a drag and drop interface. Journey stages are defined by using the criteria builder that allows marketers to specify complex boolean logic such as follows:

(customer-life-time-value > 2000 OR customer-lifetime-orders>10)

AND customer-last-visit < 2 days

AND customer-last-30-day-activity contains cateogryID=34534

AND customer-last-opened-email < 1 day

AND customer-propensity-purchase > 0.8

AND customer-progressive-registration-step1-done = true

Intel - Data Flow

Here is the overall data flow starting from events received in real-time or batch to computed values and traits enriching the customer profile or any other entity being managed within Conscia.

Predictions

When it comes to predictive scores like propensity to churn or purchase, Conscia provides the option of importing predictive scores from external sources as well as provide configurable Machine Learning Algorithms for your Data team to configure. See data onboarding for more information on how to pull data into Conscia.

Conscia provides the following Machine Learning Algorithms:

• Propensity Scores
• Real-time Intent Recognition
• Content Recommendations

Computed fields are configured in the Schema Editor dialog.

Here is an example of how you would add a customer profile attribute to model propensity:

Once the field is available, you can use a self-service dialog to configure the algorithm with relevant dimensions of the customer that can predict their propensity to buy or churn. The training process will require sufficient training data that maps customer attributes to outcomes that need to be predicted.

Once the model is ready, it can be programatically applied to the customer profiles. In order to test out various configurations of the model, Marketers and Analysts can use a sandbox environment provided by Conscia for Machine Learning and Data Analysis.

Using the above dialog, Marketers can test out the propensity scores for test customer records (shown below). The following screenshot shows the output of th propensity modeling exercise.

Audience Builder

Here is an overview of Conscia's segmentation capabilities:

• Build dynamic segments (segments are always current) using any field in customer profile including calculated fields and behavioral interaction
• Ability to create audience segments for unknown profiles around shared attributes
• Drag and Drop Segment builder
• Concentric Segments (customers can be in more than 1 segment)
• Ability to move profiles into a segment based on automation or trigger rules
• Pre-built segments - use pre-built attributes across segments
• Parent / child segments with inherited attributes
• Suppression Modeling
• Real-time dashboards and counts
• Advanced segment logic
• Export segments to other tools in MarTech

Here is how Conscia's Segment Builder is unique:

• Conscia provides a drag and drop interface for Marketers to create audience segments. No IT involvement is required to build and apply segments to customer profiles

• Any profile attribute (including raw user information, computed fields, customer's journey stages, content interactions and channel engagement) can be used to segment customers.

• Advanced audience segments can inherit the criteria from base segments (i.e. you can re-use segments within other segments).

• Marketing teams can export customer profiles for each segment in a CSV, XML or JSON format without the help of IT.

• Unprecedented flexibility in defining the logical criteria - Examples include nested boolean logic, search, regex patterns, array

Conscia provides a self-service Segment Builder for Marketers:

The easy-to-use interface allows Marketers to select a criteria from the left panel. Users can select from a number of criteria groups including:

• search
• compare, compare for arrays
• complex (and, or, not)
• check (validates if fields or values exist)
• pattern (for advanced regular expressions)

Marketers simply drag the criteria on to the canvas, select it and then input the parameters. This typically involves selecting a field and a comparision value. From there, users can repeat the process until the segment is defined.

Marketers can then trigger the taxonomy to be applied which updates the customer universe with tags associated to the newly created segment or segments.

In the example above, category segments are defined in addition to behaviour segments based on customer spending trend. These allow Marketers to quickly see the nature of a customer and also allows for quickly searching for customers based on one or many overlapping segments.

Tracking and Analytics

In most cases, your marketing team is creating and executing campaigns using a variety of tools. In order to create a unified campaign analytics view, it makes sense to capture and aggregate customer signals coming from external sources like social media, email and SMS channels in a centralized location. Conscia's Customer Identity can act as that central view for activity on all channels.

Set up event tracking within your application

With the tracking pipeline setup in Mesh, the final step is to add tracking event orchestration logic in your web application. In this example, we can simply call the analytics-webhook with the tracking information.

For Node/Browser applications, we recommend integrating the webhook as a plugin for the analytics library. An example is shown below:

<html>
  <head>
    <script src="https://unpkg.com/analytics/dist/analytics.min.js"></script>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
    <script>
      const meshAnalyticsPlugin = (config) => ({
        name: 'mesh-analytics-plugin',
        config,
        initialize: ({ config }) => {
          config.endpoint = `${config.webhookUrl}/customers/${config.customerCode}/meshKey/${config.meshKey}/webhooks/${config.webhookCode}`;
          config.headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${config.apiKey}` };
          console.log('Initialized Mesh Analytics Plugin');
        },
        page: ({ payload, config }) => {
          axios.post(
            config.endpoint,
            { stream: 'pageviews', info: payload },
            { headers: config.headers },
          );
        },
        track: ({ payload, config }) => {
          axios.post(
            config.endpoint,
            { stream: 'events', info: payload },
            { headers: config.headers },
          );
        },
        identify: ({ payload, config }) => {
          axios.post(
            config.endpoint,
            { stream: 'identify', info: payload },
            { headers: config.headers },
          );
        },
        loaded: () => true,
      });
      
      const Analytics = _analytics.init({
        app: 'my-app-name',
        debug: true,
        plugins: [meshAnalyticsPlugin({
          webhookUrl: '{{webhookUrl}}',
          customerCode: '{{customerCode}}',
          meshKey: '{{meshKey}}',
          webhookCode: 'analytics-webhook',
          apiKey: '{{apiKey}}',
        })],
      });
    </script>
    <script>
      Analytics.identify('johnsmith');
      Analytics.page();
    </script>
  </head>
  <body>
    <h1>Hello World</h1>
    <button onclick="Analytics.track('event1')">Event 1</button>
  </body>
</html>

NOTE: The apiKey used while calling the webhook in this example should be an 'offline' key generated for an app account with minimal privileges. The apiKey used for the setup API calls can have higher privileges and should be different from the former.

Conscia provides Webhooks that can be used to integrate external events (e.g. events monitored for application tracking and analytics) with the Mesh Events engine. The Mesh Events engine can then trigger a variety of Jobs to persist/process the event into an internal Mesh service such as DRS or an external service such as an analytics aggregator.

A sample setup for such an orchestration is shown below:

Set up Webhook to capture tracking events for your application

Register a webhook that will be used to submit all analytics events. Let's call this webhook analytics-webhook

POST {{meshGqlUrl}}
Content-Type: application/json
Authorization: Bearer {{apiKey}}
x-request-type: GraphQL

mutation ($input: SetWebhookInput) {
  setWebhook(input: $input)
}

{
  "input": {
    "customerCode": "{{customerCode}}",
    "meshKey": "{{meshKey}}",
    "webhookCode": "analytics-webhook",
    "webhookConfiguration": {}
  }
}

When called, this webhook will emit WebhookCalled events containing webhook metadata and submitted data to the Mesh Events queue which can handle a high throughput.

Set up Trigger to fire on WebhookCalled event

Register a trigger that will fire whenever the analytics-webhook is called. Let's call this trigger analytics-trigger. The trigger is also defined with a job type to run when a matching WebhookCalled event occurs. Mesh provides several job types, some examples are shown below:

1. Trigger a createDataRecord Job to persist tracking event to Conscia Data Collection

POST {{meshGqlUrl}}
Content-Type: application/json
Authorization: Bearer {{apiKey}}
x-request-type: GraphQL

mutation ($input: SetTriggerInput) {
  setTrigger(input: $input)
}

{
  "input" : {
    "customerCode": "{{customerCode}}",
    "meshKey": "{{meshKey}}",
    "triggerEntry": {
      "eventType": "WebhookCalled",
      "triggerCode": "analytics-trigger",
      "trigger": {
        "criteria": "`_.get(event, 'data.webhookCode') === 'analytics-webhook'`",
        "job": {
          "jobType": "createDataRecords",
          "params": {
            "customerCode": "`_.get(event, 'data.customerCode')`",
            "dataRepositoryCode": "analytics-data",
            "dataCollectionCode": "`_.get(event, 'data.req.body.stream')`",
            "dataRecords": ["`_.get(event, 'data.req.body.info')`"]
          }
        }
      }
    }
  }
}

NOTE: The above example routes tracking events into different Data Collections based on the stream value in the event payload. These Data Collections must be created in advance for the events to be persisted successfully.

2. Trigger a callWebservice Job to push tracking event to an external Analytics aggregator

POST {{meshGqlUrl}}
Content-Type: application/json
Authorization: Bearer {{apiKey}}
x-request-type: GraphQL

mutation ($input: SetTriggerInput) {
  setTrigger(input: $input)
}

{
  "input" : {
    "customerCode": "{{customerCode}}",
    "meshKey": "{{meshKey}}",
    "triggerEntry": {
      "eventType": "WebhookCalled",
      "triggerCode": "analytics-trigger",
      "trigger": {
        "criteria": "`_.get(event, 'data.webhookCode') === 'analytics-webhook'`",
        "job": {
          "jobType": "callWebservice",
          "params": {
            "options": {
              "method": "POST",
              "url": "`'https://my-analytics-api.com/' + _.get(event, 'data.req.body.stream')`",
              "followAllRedirects": true,
              "headers": {
                "content-type": "application/json"
              },
              "body": "`_.get(event, 'data.req.body.info')`"
            }
          }
        }
      }
    }
  }
}

3. Trigger a executeTaskChain Job to process the tracking event using a Mesh Task Chain

POST {{meshGqlUrl}}
Content-Type: application/json
Authorization: Bearer {{apiKey}}
x-request-type: GraphQL

mutation ($input: SetTriggerInput) {
  setTrigger(input: $input)
}

{
  "input" : {
    "customerCode": "{{customerCode}}",
    "meshKey": "{{meshKey}}",
    "triggerEntry": {
      "eventType": "WebhookCalled",
      "triggerCode": "analytics-trigger",
      "trigger": {
        "criteria": "`_.get(event, 'data.webhookCode') === 'analytics-webhook'`",
        "job": {
          "jobType": "executeTaskChain",
          "params": {
            "taskChainCode": "`'process-tracking-event-' + _.get(event, 'data.req.body.stream')`",
            "taskChainSettings": "`_.get(event, 'data.req.body.info')`",
            "runOptions": {
              "sendResultsOnComplete": false
            }
          }
        }
      }
    }
  }
}