Day7: Segmentation Service, Where AEP Starts Thinking in Audiences
Most marketing tools treat a segment as a list. Build it, save it, export it, activate it, done. That was my mental model coming in too. The deeper you go into AEP, the clearer it gets that this is not what's happening.
AEP doesn't really think in static lists. It thinks in continuously evaluated conditions. Once that lands, the Segmentation Service makes sense.
Picture a customer who visits the site, views a product, adds it to the cart, and leaves without buying. A few seconds later they qualify for an abandonment audience, a journey becomes eligible, personalization changes, and a destination gets updated. Nobody rebuilt an audience. Nobody ran a query. Nobody exported a list. The audience simply adapted to the behavior. That's the Segmentation Service.
The mental shift: rules, not lists
This is the whole episode in one idea.
-
Most platforms think: customer goes into an audience.
-
AEP thinks: behavior drives continuous evaluation, which drives audience membership.
The audience isn't the asset. The rules are. The audience is just the current result of evaluating those rules. As behavior changes, people enter audiences, exit them, and move between them, continuously.
If you come from AEM, the closest instinct is the difference between a one-time content export and a saved query that always reflects the current state of the repository. The list is frozen. The query is alive. AEP segments are the query, not the export.
What the Segmentation Service does
The simplest definition:
The Segmentation Service continuously checks whether a customer belongs in an audience.
Every segment is a set of rules, for example:
- Customers who purchased in the last 30 days
- Customers with loyalty status equal to Gold
- Customers who abandoned checkout
- Customers who viewed Product X more than three times
The service constantly evaluates those rules against Real-Time Customer Profiles. It never really stops asking the question.
One audience, three speeds
Here's the surprise. Not every segment is evaluated the same way. AEP runs segmentation at three different speeds, and knowing which is which explains a lot of real-world behavior.
Streaming reacts as events arrive. As a customer views, submits, logs in, or adds to cart, membership can update almost immediately. This is what powers most real-time use cases.
Edge evaluates audience conditions right at the Edge Network, close to the customer interaction itself. Not seconds later, potentially milliseconds. This is what enables same-page personalization, next-page recommendations, and instant qualification.
As a table:
| Batch | Streaming | Edge | |
| Evaluates | All profiles on a schedule | As events arrive | At the Edge Network |
| Latency | Hours | Seconds | Milliseconds |
| Best for | Lifetime value, campaigns | Cart abandon, live triggers | Same-page personalization |
Why some segments feel real-time and others don't
This trips people up. Some audiences update instantly, others lag. The reason is that not every segment definition qualifies for every evaluation method.
- Simple rules can run on edge or streaming.
- Complex rules fall back to batch.
The more complex the logic, the more likely it lands in the slower method. So if an audience you expected to be instant is updating slowly, the definition is probably too complex to qualify for streaming or edge. That single fact sets realistic expectations and saves a lot of confusion.
How segmentation pulls the whole series together
This is the part worth pausing on. The Segmentation Service depends on almost everything from the earlier episodes:
- XDM schemas, which define the fields rules run on
- Identity Service, which decides which records are one person
- Schema Registry governance, which keeps definitions consistent
- Real-Time Customer Profile, the assembled view it evaluates against
- Merge policies, which decide which values that view contains
Segmentation doesn't look at raw data. It evaluates against the profile AEP has already assembled. Which means the chain of consequences from the earlier posts lands here:
- Bad schemas produce bad segments.
- Weak identity strategy produces bad segments.
- Poor merge policies produce bad segments.
The segmentation engine is only as good as the profile underneath it.
The most important realization
The deeper takeaway: segmentation isn't about finding customers. It's about continuously understanding them.
Instead of asking "who is in my audience," AEP is constantly asking "based on everything I know right now, does this customer belong in this audience." And that evaluation never really stops. That's a different mindset from list-building, and it's the one that makes the rest of the platform make sense.
The one line to keep
The Segmentation Service is not a list builder. It's a continuous audience evaluation engine.
When people talk about personalization, journeys, and activation, they're usually describing what happens after segmentation. But segmentation is where the decision starts. It's the layer that turns customer behavior into audience membership.
What comes next
Day 8 moves into destinations and activation: how audiences leave AEP and become usable in Google Ads, Meta, Adobe Journey Optimizer, Customer Journey Analytics, and data warehouses. Because an audience only creates value once it can actually be activated.