Adobe RT-CDP Business Practitioner Pro cheat sheet

Real-Time CDP is built on Adobe Experience Platform; it consumes XDM data from the Profile store and streams segment membership to destinations.

Core services: Identity Service (identity graph), Profile Service (unified profiles), Segmentation Service, Destination Service, and Data Governance.

Edge network and streaming ingestion enable near-real-time segmentation; batch ingestion and evaluation are on scheduled intervals.

Streaming segmentation evaluates continuously; batch segmentation evaluates on a schedule; edge segmentation runs at data collection time.

Profile Store retains only the most recent value per attribute; Experience Event dataset stores full time-series history.

Real-time customer profile merges identities into a single profile based on the identity graph and merge policies.

RT-CDP (B2C) and RT-CDP B2B (based on Account/Person XDM classes) are distinct editions with different schema classes.

Connectors are categorized as sources (inbound) and destinations (outbound); both are configured per sandbox.

Licensing is typically based on profile volume (addressable audience) and data ingestion entitlements; sandboxes isolate data and configuration.

XDM schemas define structure; classes (e.g., XDM Individual Profile, XDM ExperienceEvent) fix required fields; field groups add reusable fields.

A schema must be enabled for Profile to contribute attributes to unified profiles; ExperienceEvent schemas feed segment event criteria.

Primary identity is set at the schema level for profile-enabled schemas; identity namespaces (Email, ECID, CRM ID) must be predefined or custom.

Identity graph links identities via shared identifiers; the namespace marked as primary identity anchors profile stitching.

Merge policies determine how conflicting profile attributes resolve: timestamp precedence, dataset precedence, or profile precedence.

Data Prep (mapping) transforms source data into XDM at ingestion; computed fields and mappings are defined per dataflow.

Batch ingestion accepts files (e.g., CSV, JSON, Parquet) via sources; streaming ingestion uses HTTP API or streaming connectors.

Data governance: labels (e.g., I, S, C) on fields and datasets enforce usage policies (DULE) at segment and destination activation.

Consent and sensitive-data policies can block activation to destinations; policy violations surface as errors or restricted fields.

Segment types: batch (scheduled), streaming (continuous), and edge (evaluated at collection, low latency, limited operators).

PQL (Profile Query Language) supports functions like count, sum, avg, min, max, exists, and time-window conditions for events.

Event-based criteria use time windows (e.g., 'in last 30 days'); window length affects evaluation cost and eligibility.

Audiences are evaluated against merged profiles; merge policy choice changes which attribute values qualify a profile.

Audience size estimates refresh on evaluation; streaming and edge audiences can show approximate counts before full evaluation.

Look-alike and propensity-style audiences rely on Adobe Sensei/Intelligent Services and require sufficient qualifying data.

Profile attributes, computed attributes, and segment membership can themselves be used as segment criteria (nested audiences).

Audience activation requires the destination to support the identity namespace used by the audience (e.g., hashed email).

Profile viewer shows a single merged profile; identity graph view shows linked identities and namespaces.

Destination types: profile-based (audience export to ad/marketing platforms) and dataset-based (raw data export), plus edge destinations.

Activation flow: select destination, choose audience, map source attributes/identities to destination fields, set schedule, then review.

Identity mapping must resolve to a namespace the destination accepts; unmapped required identities block activation.

Streaming destinations deliver near-real-time audience updates; batch destinations deliver on a schedule (e.g., daily, hourly).

Destination dataflow run history shows success/failure per run; failed runs list the reason (auth, mapping, policy).

Consent/governance policies are enforced at activation; labeled fields may be excluded or the activation blocked.

Destination audience removal (deactivation) sends deletion/removal signals where the destination supports it.

Same audience can activate to multiple destinations simultaneously; each activation has independent mapping and schedule.

Test destinations and dataflow monitoring help validate mappings before production activation.

Sandboxes isolate schemas, datasets, profiles, audiences, and destinations; production and development are commonly separated by sandbox.

Role-based access control (RBAC) governs permissions by product profile and permission sets (e.g., manage datasets, manage destinations).

Dataset expiration and profile expiration (TTL) settings remove stale data; TTL values are configured per dataset/sandbox.

Data hygiene: delete/update requests (privacy service) remove or modify records, and deletion propagates to datasets and profiles.

Common ingestion failures: schema mismatch, missing required identity, invalid namespace, and malformed timestamps or data types.

Profile count discrepancies often trace to merge policy differences, identity stitching gaps, or expired data.

Audience size not matching expectation: check merge policy, event time windows, and whether the schema is Profile-enabled.

Monitoring dashboards surface ingestion errors, dataflow run status, and destination run history for diagnosis.

Audit logs record administrative and configuration changes for compliance and troubleshooting.

Edge segmentation runs at data collection on the edge network; operators are limited compared to batch/streaming.

Streaming segmentation requires the schema to be Profile-enabled and an identity to be present on each event.

Real-time profile updates are reflected in streaming audiences shortly after ingestion; batch audiences update on schedule.

Destinations consume segment membership changes; streaming destinations push near-real-time, batch destinations pull on schedule.

Identity graph is the foundation for profile stitching; missing identity namespaces prevent profile unification.

Data governance policies (DULE) are evaluated at both segment creation and destination activation.

Sandbox boundaries prevent cross-sandbox data sharing; schemas and destinations are sandbox-scoped.

Licensing profile volume counts unified profiles in the production sandbox, not raw event volume.

Computed attributes and derived fields are evaluated in the profile and can feed segmentation.

XDM field groups are reusable; multiple schemas can share the same field group definitions.

Identity namespaces have a type (cookie, email, phone, CRM ID, etc.) and an identity symbol; custom namespaces must be created before use.

Primary identity is required for Profile-enabled schemas; it anchors profile stitching in the identity graph.

Merge policy default is timestamp precedence unless a dataset or profile precedence policy overrides it.

Data Prep mapping transforms source fields to XDM; computed fields derive new values during ingestion.

Dataset labels and field-level labels drive policy enforcement; sensitive labels can restrict activation.

Batch ingestion supports partial success; failed records are reported in error diagnostics per batch.

Streaming ingestion via HTTP API requires valid authentication, schema reference, and identity.

Consent policies can block ingestion or activation depending on configuration and labels.

Batch segmentation evaluates on a schedule; streaming evaluates continuously; edge evaluates at collection.

PQL functions include count, sum, avg, min, max, exists, and time-window predicates for event-based criteria.

Event criteria use time windows (e.g., 'in last 30 days'); shorter windows reduce evaluation cost and audience size.

Merge policy determines which profile attribute value is used when multiple sources conflict.

Nested audiences use existing segment membership as criteria, enabling layered targeting.

Audience activation requires identity mapping to a namespace the destination supports.

Profile viewer shows merged attributes; identity graph shows linked identities and namespaces.

Audience size estimates refresh on evaluation; streaming/edge audiences may show approximate counts initially.

Look-alike audiences require sufficient qualifying data and use Adobe Sensei/Intelligent Services.

Profile-based destinations export audience membership; dataset-based destinations export raw data.

Activation requires mapping source identities/attributes to destination fields; unmapped required identities block activation.

Streaming destinations deliver near-real-time updates; batch destinations deliver on a schedule.

Destination run history shows success/failure and reasons (auth, mapping, policy).

Governance policies are enforced at activation; labeled fields may be excluded or activation blocked.

Deactivation removes audience membership from the destination where supported.

One audience can activate to multiple destinations with independent mappings and schedules.

Test destinations validate mappings before production activation.

Edge destinations support low-latency activation from edge segmentation.

Sandboxes isolate schemas, datasets, profiles, audiences, and destinations; production and development are commonly separated.

RBAC uses product profiles and permission sets (e.g., manage datasets, manage destinations).

Dataset and profile expiration (TTL) settings remove stale data; TTL is configured per dataset/sandbox.

Privacy service delete/update requests remove or modify records and propagate to datasets and profiles.

Common ingestion failures: schema mismatch, missing required identity, invalid namespace, malformed timestamps/types.

Profile count discrepancies trace to merge policy differences, identity stitching gaps, or expired data.

Audience size mismatches: check merge policy, event time windows, and Profile-enabled schema status.

Monitoring dashboards show ingestion errors, dataflow run status, and destination run history.

Audit logs record administrative and configuration changes for compliance.

RT-CDP is built on Adobe Experience Platform and consumes XDM data from the Profile store.

Core services: Identity Service, Profile Service, Segmentation Service, Destination Service, Data Governance.

Edge network and streaming ingestion enable near-real-time segmentation; batch evaluation is scheduled.

Streaming segmentation evaluates continuously; batch on schedule; edge at collection.

Profile Store retains latest value per attribute; Experience Event dataset stores full history.

Real-time profile merges identities via the identity graph and merge policies.

RT-CDP B2C and B2B editions use different schema classes (Account/Person vs Individual Profile).

Connectors are sources (inbound) and destinations (outbound), configured per sandbox.

Licensing is based on profile volume and ingestion entitlements; sandboxes isolate data/configuration.

XDM classes fix required fields; field groups add reusable fields; schemas must be Profile-enabled to feed profiles.

Primary identity is set at the schema level for Profile-enabled schemas; namespaces must exist before use.

Identity graph links identities via shared identifiers; primary identity anchors stitching.

Merge policies resolve conflicting attributes: timestamp, dataset, or profile precedence.

Data Prep maps and computes fields at ingestion per dataflow.

Batch ingestion accepts files via sources; streaming uses HTTP API or streaming connectors.

Governance labels (I, S, C) enforce usage policies (DULE) at segmentation and activation.

Consent and sensitive-data policies can block activation; violations appear as errors or restricted fields.

Partial batch success reports failed records in error diagnostics.

Segment types: batch, streaming, and edge (limited operators at edge).

PQL supports count, sum, avg, min, max, exists, and time-window conditions.

Event criteria use time windows; window length affects cost and eligibility.

Audiences evaluate against merged profiles; merge policy changes qualifying attribute values.

Audience size estimates refresh on evaluation; streaming/edge may show approximate counts.

Look-alike audiences use Adobe Sensei and require sufficient data.

Profile attributes, computed attributes, and segment membership can be segment criteria (nested audiences).

Activation requires the destination to support the audience's identity namespace.

Profile viewer shows merged profile; identity graph shows linked identities.

Destination types: profile-based, dataset-based, and edge destinations.

Activation flow: select destination, choose audience, map attributes/identities, set schedule, review.

Identity mapping must resolve to a namespace the destination accepts; unmapped required identities block activation.

Streaming destinations deliver near-real-time updates; batch on schedule.

Run history shows success/failure with reasons (auth, mapping, policy).

Governance policies enforced at activation; labeled fields may be excluded or blocked.

Deactivation sends removal signals where supported.

One audience can activate to multiple destinations with independent mappings/schedules.

Test destinations and monitoring validate mappings before production.

Sandboxes isolate schemas, datasets, profiles, audiences, and destinations.

RBAC governs permissions via product profiles and permission sets.

Dataset/profile expiration (TTL) removes stale data; configured per dataset/sandbox.

Privacy service delete/update requests remove or modify records and propagate to datasets/profiles.

Common ingestion failures: schema mismatch, missing identity, invalid namespace, malformed timestamps/types.

Profile count discrepancies trace to merge policy, identity stitching gaps, or expired data.

Audience size mismatch: check merge policy, time windows, Profile-enabled schema.

Monitoring dashboards show ingestion errors, dataflow status, destination run history.

Audit logs record administrative and configuration changes.

RT-CDP on AEP; consumes XDM from Profile store and streams segment membership to destinations.

Core services: Identity, Profile, Segmentation, Destination, Data Governance.

Edge network and streaming ingestion enable near-real-time segmentation.

Streaming evaluates continuously; batch on schedule; edge at collection.

Profile Store retains latest attribute value; Experience Event dataset stores history.

Real-time profile merges identities via identity graph and merge policies.

B2C vs B2B editions use different schema classes.

Connectors are sources (inbound) and destinations (outbound), per sandbox.

Licensing based on profile volume and ingestion entitlements; sandboxes isolate data.

XDM classes fix required fields; field groups add reusable fields; Profile-enabled schemas feed profiles.

Primary identity set at schema level; namespaces must exist before use.

Identity graph links identities via shared identifiers; primary identity anchors stitching.

Merge policies resolve conflicts: timestamp, dataset, or profile precedence.

Data Prep maps/computes fields at ingestion per dataflow.

Batch ingestion accepts files via sources; streaming via HTTP API/connectors.

Governance labels (I, S, C) enforce policies (DULE) at segmentation and activation.

Consent/sensitive-data policies can block activation; violations show as errors/restricted fields.

Partial batch success reports failed records in diagnostics.

Segment types: batch, streaming, edge (limited operators).

PQL supports count, sum, avg, min, max, exists, time-window conditions.

Event criteria use time windows; window length affects cost/eligibility.

Audiences evaluate against merged profiles; merge policy affects qualifying values.

Audience size estimates refresh on evaluation; streaming/edge may show approximate counts.

Look-alike audiences use Adobe Sensei and need sufficient data.

Attributes, computed attributes, and segment membership can be criteria (nested audiences).

Activation requires destination support for the audience's identity namespace.

Profile viewer shows merged profile; identity graph shows linked identities.

Destination types: profile-based, dataset-based, edge.

Activation flow: select destination, audience, map attributes/identities, schedule, review.

Identity mapping must resolve to a namespace the destination accepts; unmapped required identities block activation.

Streaming destinations deliver near-real-time; batch on schedule.

Run history shows success/failure with reasons (auth, mapping, policy).

Governance policies enforced at activation; labeled fields may be excluded or blocked.

Deactivation sends removal signals where supported.

One audience can activate to multiple destinations with independent mappings/schedules.

Test destinations and monitoring validate mappings before production.

Sandboxes isolate schemas, datasets, profiles, audiences, destinations.

RBAC governs permissions via product profiles and permission sets.

Dataset/profile expiration (TTL) removes stale data; configured per dataset/sandbox.

Privacy service delete/update requests propagate to datasets/profiles.

Common ingestion failures: schema mismatch, missing identity, invalid namespace, malformed types.

Profile count discrepancies trace to merge policy, stitching gaps, expired data.

Audience size mismatch: check merge policy, time windows, Profile-enabled schema.

Monitoring dashboards show ingestion errors, dataflow status, destination run history.

Audit logs record administrative and configuration changes.

RT-CDP on AEP; consumes XDM from Profile store and streams segment membership to destinations.

Core services: Identity, Profile, Segmentation, Destination, Data Governance.

Edge network and streaming ingestion enable near-real-time segmentation.

Streaming evaluates continuously; batch on schedule; edge at collection.

Profile Store retains latest attribute value; Experience Event dataset stores history.

Real-time profile merges identities via identity graph and merge policies.

B2C vs B2B editions use different schema classes.

Connectors are sources (inbound) and destinations (outbound), per sandbox.

Licensing based on profile volume and ingestion entitlements; sandboxes isolate data.

XDM classes fix required fields; field groups add reusable fields; Profile-enabled schemas feed profiles.

Primary identity set at schema level; namespaces must exist before use.

Identity graph links identities via shared identifiers; primary identity anchors stitching.

Merge policies resolve conflicts: timestamp, dataset, or profile precedence.

Data Prep maps/computes fields at ingestion per dataflow.

Batch ingestion accepts files via sources; streaming via HTTP API/connectors.

Governance labels (I, S, C) enforce policies (DULE) at segmentation and activation.

Consent/sensitive-data policies can block activation; violations show as errors/restricted fields.

Partial batch success reports failed records in diagnostics.

Segment types: batch, streaming, edge (limited operators).

PQL supports count, sum, avg, min, max, exists, time-window conditions.

Event criteria use time windows; window length affects cost/eligibility.

Audiences evaluate against merged profiles; merge policy affects qualifying values.

Audience size estimates refresh on evaluation; streaming/edge may show approximate counts.

Look-alike audiences use Adobe Sensei and need sufficient data.

Attributes, computed attributes, and segment membership can be criteria (nested audiences).

Activation requires destination support for the audience's identity namespace.

Profile viewer shows merged profile; identity graph shows linked identities.

Destination types: profile-based, dataset-based, edge.

Activation flow: select destination, audience, map attributes/identities, schedule, review.

Identity mapping must resolve to a namespace the destination accepts; unmapped required identities block activation.

Streaming destinations deliver near-real-time; batch on schedule.

Run history shows success/failure with reasons (auth, mapping, policy).

Governance policies enforced at activation; labeled fields may be excluded or blocked.

Deactivation sends removal signals where supported.

One audience can activate to multiple destinations with independent mappings/schedules.

Test destinations and monitoring validate mappings before production.

Sandboxes isolate schemas, datasets, profiles, audiences, destinations.

RBAC governs permissions via product profiles and permission sets.

Dataset/profile expiration (TTL) removes stale data; configured per dataset/sandbox.

Privacy service delete/update requests propagate to datasets/profiles.

Common ingestion failures: schema mismatch, missing identity, invalid namespace, malformed types.

Profile count discrepancies trace to merge policy, stitching gaps, expired data.

Audience size mismatch: check merge policy, time windows, Profile-enabled schema.

Monitoring dashboards show ingestion errors, dataflow status, destination run history.

Audit logs record administrative and configuration changes.