Adobe Journey Optimizer Developer Expert cheat sheet

Journey states are Draft, Published, Stopped, and Closed; only a Published journey accepts new profiles, and Closed is terminal and cannot be republished.

Re-entrance rules: a profile can re-enter only if the journey's re-entrance window has elapsed; re-entrance is disabled entirely when using a Read Audience or an event with no re-entrance allowance.

An event triggered journey requires a namespace and event ID; the event must be associated with a profile identity to start a journey.

Wait activities support a duration or a time condition; a time condition caps the wait at a maximum duration so profiles do not wait indefinitely.

The journey canvas limits: one journey can contain up to 50 activities/nodes in a path; branching uses conditions with a maximum of 20 paths per condition node (verify against current release notes).

A profile can be in only one instance of the same journey at a time; simultaneous entry is blocked by the journey's re-entrance configuration.

Journey reports expose counts for entered, exited, and errored profiles; the 'error' count reflects activity-level failures such as message send rejection.

Custom actions call external systems via a configured action with URL, authentication, and payload; they run asynchronously and do not block the journey path.

The XDM schema is the contract for a dataset; a schema field must exist before data can be ingested into it, and schema changes are additive for published schemas.

Segment membership is evaluated by the segmentation service; batch segments evaluate on a schedule, while streaming/edge segments evaluate as events arrive.

A profile-enabled dataset is required for profile attributes to be usable in segmentation; non-profile datasets feed only dataset-level queries.

Merge policies determine which profile attributes win when multiple datasets contribute conflicting values; the default merge policy uses timestamp-based precedence.

Segment qualification events can trigger journeys; the 'Audience enters segment' event requires the segment to be evaluated in streaming or edge mode.

Identity namespaces define how identities are stitched into a profile; the identity graph links ECIDs, CRM IDs, and other namespaces via the identity map.

Audiences built with an 'Audience' node inside a segment (segment-of-segments) inherit the evaluation method of the referenced segment.

Data ingestion via streaming, batch, or source connectors all land in datasets; dataset-level data lifecycle policies control retention and expiration.

A channel surface (email, push, SMS) must be configured with the correct subdomain, IP pool, and sender identity before a message can be published.

Email deliverability depends on the sending domain's authentication (SPF, DKIM, DMARC); the configured subdomain must match the DNS records provisioned in the platform.

Push notifications require a platform application (APNs for iOS, FCM for Android) and a push credential bound to the channel surface.

Message authoring uses a content template; personalization tokens must resolve at send time or the message fails validation before publish.

Proof and test sends use the test profile; a message cannot be published if required fields (subject, sender, content) are missing.

Send-time optimization and throttling are configured at the channel surface or campaign level; they do not override journey-level frequency caps.

Delivery failures surface as bounces or errors in the message feedback; hard bounces suppress the address for future sends.

SMS messages route through a configured provider and require an approved sender ID or short code per destination country.

Offer decisioning evaluates eligibility, then ranking, then capping: an offer must be eligible for the profile and within its frequency cap to be returned.

A decision is composed of a placement, a collection of offers, and a decision policy; the policy supplies the ranking formula and capping rules.

Ranking formulas can be static (priority) or dynamic (AI-scored); dynamic ranking requires sufficient decision events to train.

Frequency capping is enforced per profile per offer (or per placement) over a configured window; capping is evaluated at decision time.

Fallback offers are returned when no eligible offer passes; a placement without a fallback can return an empty decision.

Personalization uses profile attributes, contextual attributes, and helper functions; the profile must be resolved before personalization can read attributes.

Offer eligibility rules are expressed as decision rules (PQL-like conditions) referencing profile or contextual data; an ineligible offer is excluded from ranking.

Simulation and preview in the decisioning UI let you test a decision against a sample profile or context without sending a real message.

Sandbox isolation separates schemas, datasets, journeys, and configurations; a sandbox cannot share objects with another sandbox.

Role-based access control uses product profiles and permissions; a developer needs journey and channel permissions to publish, not just author.

Audit logs record configuration changes (who changed what and when) and are the primary source for governance investigations.

Data usage policies and labels (DULE) restrict how labeled fields may be used in segmentation and personalization; a policy violation blocks the action.

The journey and dataset diagnostics surface errors with error codes; common causes are schema mismatch, missing identity, and unpublished channel surface.

Alerts can be configured on journey errors, dataset ingestion failures, and segment evaluation failures to notify administrators.

Deleting a schema or dataset that is referenced by a journey or segment is blocked; references must be removed first.

API credentials and OAuth tokens are managed per sandbox; rotating a credential requires updating the configured action or source integration.

A journey can use a 'Read Audience' activity to batch-load profiles; this disables event-based re-entrance and runs on the audience's evaluation schedule.

Condition nodes evaluate profile or contextual attributes and route to two or more paths; the default path catches profiles that match no condition.

The 'Wait' activity's time condition uses a fixed date or a profile attribute date; a profile whose date has passed exits the wait immediately.

Journey versioning: editing a published journey creates a new version; in-flight profiles continue on the version they entered.

Journey-level frequency capping limits how many messages a profile receives across the journey, independent of channel-level caps.

The 'Jump' activity moves a profile to another point in the same journey; it cannot jump to a different journey.

Journey testing uses test profiles and a test mode that simulates the path without sending real messages.

A journey's schedule can be set to start immediately, at a date, or on a recurring basis; recurring journeys re-evaluate their audience each run.

Streaming segmentation uses the edge or streaming evaluation; edge segments are evaluated near the event source and support real-time journey entry.

Batch segmentation runs on a schedule; the segment's evaluation schedule determines when membership updates and journey triggers fire.

Segment definitions can combine profile attributes, experience events, and audience membership; experience-event conditions require a time window.

The identity graph merges identities across namespaces; a profile with conflicting identities may resolve to the most recently seen identity per merge policy.

Data prep (mapping) transforms source data into the XDM schema; a mapping error routes the record to the failed-records dataset.

Dataset retention and expiration are governed by data lifecycle policies; expired records are removed and no longer contribute to segments.

Segment preview shows an estimated count and a sample of qualifying profiles; it does not guarantee the final membership count.

Lookup and enrichment datasets join reference data to profiles; the join key must be a profile identity or a matching attribute.

Email IP warming ramps sending volume gradually on a new IP pool; skipping warming increases bounce and complaint rates.

The message's 'from' address, reply-to, and subdomain must be consistent with the authenticated sending domain; mismatches hurt deliverability.

Push payloads have size limits (APNs ~4KB, FCM ~4KB); oversized payloads are rejected at send time.

SMS opt-in and opt-out keywords are managed by the provider; the platform must honor the suppression list before sending.

A message can be sent from a journey, a campaign, or an API-triggered call; all paths use the same channel surface configuration.

Delivery reports distinguish sent, delivered, bounced, and errored; a 'sent' count is not a 'delivered' count.

Content templates can be shared across messages; editing a shared template affects every message that references it.

Frequency caps and quiet hours are enforced at send time; a message suppressed by a cap is not counted as a delivery failure.

The decisioning flow is: collect eligible offers, apply ranking, apply capping, return the top offer(s) per placement.

Decision rules use contextual and profile attributes; a rule referencing an unresolved attribute evaluates as false and excludes the offer.

AI ranking models require a configured optimization objective and enough decision events; a new model starts in a learning phase.

Offer representations are the channel-specific content (image, text) attached to an offer; the placement selects which representation to render.

The decision API returns a decision ID; decision events (impression, click) must be sent back to train ranking and enforce capping.

Fallback offers are selected from the placement's fallback list and are not subject to ranking; they are used when no eligible offer exists.

Personalization helper functions include date/time, math, and string functions; they run at render time and cannot change journey routing.

Capping is evaluated against decision events, not message sends; a decision returned but never rendered still counts if an impression event is sent.

Product profiles map to permissions; assigning a user to a product profile grants the permissions bundled in that profile within the sandbox.

Data usage labels (e.g., C1, C2, I1) are attached to schema fields; policies evaluate these labels against the action being performed.

The audit log captures create, update, and delete events with actor, timestamp, and object; it does not capture read operations.

Common journey error: 'profile not in audience' or 'event not received' indicates the entry condition or identity mapping is wrong.

Common dataset error: schema field missing or type mismatch routes records to failed records; check the failed-records dataset for the payload.

Alerts and health dashboards surface ingestion lag, segment evaluation failures, and journey error spikes; use them before deep-dive debugging.

Deleting an object referenced by a journey, segment, or decision is blocked; remove references or deactivate the dependent object first.

API rate limits apply per sandbox; exceeding them returns 429 errors that surface as journey or ingestion failures.

Publishing a journey validates its activities; a validation error blocks publish and lists the failing node.

Stopping a journey halts new entries but lets in-flight profiles finish their current wait and activities; closing a journey ends all profiles.

The journey's entry condition is evaluated at entry; a profile that later qualifies does not enter a non-recurring journey that already started.

Event-triggered journeys require the event schema to include the profile identity; a missing identity prevents entry.

The journey report's 'error' metric counts activity failures; the 'dropped' metric counts profiles that exited via a condition or timeout.

A journey can reference a segment as an entry audience; the segment must be evaluated in streaming or edge mode for event-like entry.

Custom actions have a timeout; a slow external endpoint can cause activity errors and profile drops.

Journey copies create a new draft with the same activities but no in-flight profiles; the copy must be published to run.

A schema must be enabled for profile before its dataset can contribute to the unified profile; otherwise attributes are not usable in segmentation.

The union schema is the merged view of all profile-enabled schemas; segment conditions reference union schema fields.

Streaming ingestion requires a dataset with a streaming source and a valid schema; batch ingestion uses files or connectors.

Segment evaluation errors often stem from a field that is not profile-enabled or a namespace that is not in the identity graph.

The identity map is an array of identity objects; a profile is resolved by matching any namespace in the map against the identity graph.

Segment counts can differ from journey entry counts because entry also requires the journey's entry condition and re-entrance rules.

Data prep mapping errors are visible in the failed-records dataset; fix the mapping and replay the failed records.

Deleting a profile requires an identity delete request; the profile is removed from the identity graph and from future segment evaluations.

A channel surface must be associated with a message before publish; a missing surface blocks the publish action.

Email subdomain delegation requires DNS records (CNAME) provisioned by the platform; until verified, sends fail or are throttled.

Push credentials (APNs certificate or key, FCM server key) expire; an expired credential causes push send failures.

Message content validation checks personalization tokens; an unresolved token fails validation and blocks publish.

Proof sends use the test profile and do not count toward frequency caps or delivery metrics.

Suppression lists (bounce, complaint, opt-out) are checked at send time; a suppressed address is skipped and logged.

Campaign and journey sends share the channel surface; changing the surface affects all messages using it.

Delivery metrics distinguish 'sent' from 'delivered'; a high sent-to-delivered gap indicates deliverability or provider issues.

A placement defines where an offer appears (e.g., email banner, web); the decision request specifies the placement.

An offer collection groups offers for a decision; only offers in the collection are considered for that decision.

The decision policy's ranking formula orders eligible offers; the top-ranked offer per placement is returned.

Capping rules are configured in the decision policy and evaluated against decision events over a time window.

Fallback offers are configured per placement and returned when no eligible offer passes ranking and capping.

Decision events (impression, click) must be sent to the decisioning API to train AI ranking and enforce capping.

Preview and simulation in the decisioning UI test a decision against a sample profile without sending a message.

A decision rule referencing a missing attribute evaluates false, excluding the offer; check attribute names before publishing.

Sandbox permissions are granted per product profile; a user with no profile in a sandbox cannot access its objects.

The audit log is queried by object type, actor, and date; it is the source of truth for who changed a configuration.

Data usage policies block actions (e.g., segmentation, personalization) when a labeled field is used in a disallowed way.

Journey diagnostics list error codes per activity; map the code to the failing configuration (surface, schema, identity).

Dataset diagnostics show ingestion failures and failed-record counts; inspect the failed-records dataset for the payload.

Alerts can be configured for journey errors, ingestion failures, and segment evaluation failures; they notify via the configured channel.

API credentials are scoped per sandbox; a credential from one sandbox does not work in another.

Deleting a referenced object is blocked; deactivate or remove references before deletion.

A journey starts with an event, an audience, or a scheduled audience read; the start node determines entry semantics.

The 'Read Audience' start node batch-loads profiles and disables event-based re-entrance.

Condition nodes branch on profile or contextual attributes; the default branch catches non-matching profiles.

Wait activities pause a profile for a duration or until a time condition; a maximum duration prevents indefinite waits.

Custom actions call external systems with a configured URL and authentication; they run asynchronously.

The 'Jump' activity moves a profile within the same journey; it cannot cross journeys.

Journey versioning keeps in-flight profiles on their entry version; edits create a new version for new entries.

Journey-level frequency capping limits messages per profile across the journey, independent of channel caps.

The XDM schema defines fields and types; a field must exist before ingestion, and published schema changes are additive.

Profile-enabled datasets feed the unified profile; non-profile datasets feed only dataset-level queries.

Merge policies resolve conflicting profile attributes; the default uses timestamp precedence.

Streaming and edge segments evaluate in near real time and can trigger journeys; batch segments evaluate on a schedule.

The identity graph stitches identities across namespaces; the identity map on each record supplies the identities.

Segment-of-segments inherits the evaluation method of the referenced segment.

Data prep maps source data to XDM; mapping errors route records to the failed-records dataset.

Data lifecycle policies control retention; expired records no longer contribute to segments.

A channel surface binds a subdomain, IP pool, and sender identity; it must exist before a message can publish.

Email authentication (SPF, DKIM, DMARC) must be configured on the sending subdomain for deliverability.

Push requires a platform application (APNs, FCM) and a valid credential bound to the surface.

Personalization tokens must resolve at send time; unresolved tokens fail validation and block publish.

Proof sends use the test profile and do not count toward frequency caps or delivery metrics.

Suppression lists (bounce, complaint, opt-out) are checked at send time and skipped addresses are logged.

Delivery metrics distinguish sent from delivered; a large gap indicates deliverability or provider issues.

SMS requires an approved sender ID or short code per destination country.

Decisioning evaluates eligibility, then ranking, then capping; only eligible, uncapped offers are returned.

A decision combines a placement, a collection, and a decision policy (ranking and capping).

Ranking formulas are static (priority) or dynamic (AI); dynamic ranking needs sufficient decision events.

Frequency capping is enforced per profile per offer or placement over a configured window at decision time.

Fallback offers are returned when no eligible offer passes; a placement without a fallback can return empty.

Personalization reads profile and contextual attributes; the profile must be resolved before attributes are available.

Decision rules referencing missing attributes evaluate false and exclude the offer.

Simulation and preview test a decision against a sample profile without sending a message.

Sandboxes isolate schemas, datasets, journeys, and configurations; objects cannot be shared across sandboxes.

Product profiles bundle permissions; a user needs the right profile in the sandbox to publish journeys or messages.

Audit logs record configuration changes with actor, timestamp, and object; reads are not captured.

Data usage labels and policies (DULE) restrict how labeled fields are used in segmentation and personalization.

Journey and dataset diagnostics surface error codes; common causes are schema mismatch, missing identity, and unpublished surface.

Alerts can notify on journey errors, ingestion failures, and segment evaluation failures.

Deleting a referenced schema or dataset is blocked until references are removed.

API credentials are scoped per sandbox; rotating a credential requires updating the integration.

Test mode simulates the journey path with test profiles without sending real messages.

Test profiles must have the identity the journey's start node requires to enter.

The journey report's 'entered', 'exited', and 'error' counts help validate the path after a test run.

A journey in Draft cannot receive real profiles; publish to run.

Re-entrance settings determine whether a test profile can re-enter during testing.

Activity-level errors in test mode surface the same error codes as production.

Custom actions in test mode still call the external endpoint unless the action is mocked.

Stopping a journey halts new entries but lets in-flight profiles finish; closing ends all profiles.

Segment preview shows an estimated count and sample profiles; it does not guarantee final membership.

Streaming segments update as events arrive; batch segments update on their evaluation schedule.

A field not enabled for profile cannot be used in segment conditions; enable it on the schema first.

The identity namespace used in a segment condition must exist in the identity graph.

Failed-records datasets capture records that fail schema or mapping validation.

Merge policies affect which attribute value a segment condition sees when datasets conflict.

Segment-of-segments inherits the referenced segment's evaluation method.

Data lifecycle policies can remove records and change segment membership over time.

Proof sends use the test profile and do not count toward frequency caps or delivery metrics.

A message with an unresolved personalization token fails validation and cannot publish.

An expired push credential causes send failures; rotate the credential before testing.

Email subdomain DNS verification must complete before sends succeed.

Suppression lists are checked at send time; suppressed addresses are skipped and logged.

Delivery reports distinguish sent, delivered, bounced, and errored counts.

SMS sender IDs must be approved per destination country before testing.

Editing a shared content template affects every message that references it.

Simulation tests a decision against a sample profile or context without sending a message.

Preview shows which offer a placement returns for the selected profile.

A decision rule referencing a missing attribute evaluates false and excludes the offer.

Capping is evaluated against decision events; a test without impression events does not consume the cap.

Fallback offers are returned when no eligible offer passes ranking and capping.

AI ranking models start in a learning phase and need decision events to train.

Decision events (impression, click) must be sent to train ranking and enforce capping.

The decision API returns a decision ID used to correlate events.

Audit logs capture create, update, and delete events with actor and timestamp; reads are not captured.

Data usage policies block actions when a labeled field is used in a disallowed way.

Journey diagnostics list error codes per activity; map each code to the failing configuration.

Dataset diagnostics show ingestion failures and failed-record counts.

Alerts can be configured for journey errors, ingestion failures, and segment evaluation failures.

API rate limits return 429 errors that surface as journey or ingestion failures.

Deleting a referenced object is blocked until references are removed.

API credentials are scoped per sandbox and do not work across sandboxes.

Journey reports show entered, exited, and error counts per journey and per activity.

The 'dropped' metric counts profiles that exited via a condition, timeout, or error.

Activity-level errors surface error codes that map to configuration problems.

Stopping a journey halts new entries; in-flight profiles finish their current activities.

Closing a journey ends all profiles and is terminal.

Journey-level frequency capping limits messages per profile across the journey.

Custom action timeouts cause activity errors and profile drops.

Journey copies create a new draft with no in-flight profiles.

Dataset diagnostics show ingestion failures and failed-record counts.

The failed-records dataset holds records that fail schema or mapping validation.

Streaming ingestion lag is visible in dataset health; high lag delays segment updates.

Segment evaluation failures surface in segment diagnostics with an error reason.

Profile-enabled datasets feed the unified profile; non-profile datasets do not.

Merge policies resolve conflicting attribute values across datasets.

Data lifecycle policies remove expired records and change segment membership.

Identity graph conflicts resolve by merge policy and most-recent identity.

Delivery reports distinguish sent, delivered, bounced, and errored counts.

A high sent-to-delivered gap indicates deliverability or provider issues.

Suppression lists are checked at send time; skipped addresses are logged.

Expired push credentials cause push send failures; monitor credential expiry.

Email subdomain DNS verification failures block or throttle sends.

Frequency caps and quiet hours suppress messages at send time; suppressed messages are not delivery failures.

Editing a shared template affects all referencing messages.

SMS provider opt-out keywords must be honored before sending.

Decision events (impression, click) train AI ranking and enforce capping.

Capping counts decision events, not message sends; an unrendered decision still counts if an impression is sent.

AI ranking models start in a learning phase and need sufficient events.

Fallback offers are not ranked and are used when no eligible offer exists.

Decision rules referencing missing attributes exclude the offer.

The decision API returns a decision ID used to correlate events.

Simulation and preview test decisions without sending messages.

Placements select which representation renders per channel.

Audit logs record configuration changes; reads are not captured.

Data usage policies block disallowed uses of labeled fields.

Journey and dataset diagnostics surface error codes for root-cause analysis.

Alerts notify on journey errors, ingestion failures, and segment evaluation failures.

API rate limits return 429 errors that surface as failures.

Deleting referenced objects is blocked until references are removed.

API credentials are scoped per sandbox.

Product profiles bundle permissions per sandbox.

The start node (event, audience, scheduled audience) determines entry semantics and re-entrance.

Event-triggered journeys require the event schema to include the profile identity.

Condition nodes branch on profile or contextual attributes with a default branch.

Wait activities pause for a duration or until a time condition with a maximum.

Custom actions call external systems asynchronously with configured authentication.

The Jump activity moves profiles within the same journey only.

Journey versioning keeps in-flight profiles on their entry version.

Journey-level frequency capping is independent of channel caps.

A schema field must exist before ingestion; published schema changes are additive.

Profile-enabled datasets feed the unified profile and segmentation.

Merge policies resolve conflicting attributes by timestamp precedence by default.

Streaming and edge segments support near-real-time journey entry; batch segments run on a schedule.

The identity map supplies identities; the identity graph stitches them across namespaces.

Segment-of-segments inherits the referenced segment's evaluation method.

Data prep maps source data to XDM; mapping errors route to failed records.

Data lifecycle policies control retention and segment membership.