Lens : See what Adobe tools don't show you [ERD]

ADOBE EXPERIENCE PLATFORM (AEP)

Pradeep Jaiswal

8/4/20266 min read

First in a series walking through each tab in Lens. Starting with the ERD, because it's the one people open first and the one that changes how the rest of the tool makes sense.

Anyone who has been handed an unfamiliar Adobe Experience Platform sandbox knows the specific flavor of dread. There are sixty schemas. Half of them have names like Customer Profile v2 FINAL. Someone built this two years ago, that person left, and now you need to answer a simple question: if I bring in this new data, what does it connect to?

Adobe will happily show you a list. A list is alphabetical. A list tells you what exists. It does not tell you how anything fits together, and "how it fits together" is the entire job. That's the gap the Schema ERD tab fills.

What you're looking at when you open it.

Pick a sandbox, hit Refresh, and Lens draws every user-created schema in that sandbox as a card, arranged like a proper entity-relationship diagram.

The cards are grouped and color-coded by schema type, and the grouping is the first thing worth reading. There are three types: XDM-Standard, XDM-Custom, and Relational. Each splits again by whether it's a record or a time-series schema.

XDM-Standard record schemas are your Profile schemas, time-series are Events.

XDM-Custom record schemas are Lookups. So before you've read a single field name, the shape of the picture already tells you how much of this sandbox is profile data, how much is behavioral, and how much is reference data hanging off the side.

You Can't Fix What You Can't See.

I've spent over sixteen years in Adobe consulting, working across Analytics, AEP, CJA, AJO, and Target. Every one of those tools demands serious technical depth before you can customize it far enough to actually deliver what a client is asking for.

And almost all of them ship with APIs. The information you need is right there, reachable from the backend, but the UI simply doesn't show

it. Getting to it meant writing code and knowing the system well enough to know what to ask for.

I've never been a full-stack developer. AI changed that for me, and I can finally build the thing I kept wishing every one of these tools had shipped with by default.

That's why I started building a Chrome extension. Link

Lens · See what Adobe tools don't show you

Each card lists that schema's key attributes. A 🫆fingerprint marks an identity attribute.

Little superscript letters after a field name tell you the job it does: PI for primary identity, PK for primary key, RK for relational key, VD for version descriptor, TS for timestamp descriptor. It's a small thing that saves an enormous amount of clicking, because those five roles are exactly what you'd otherwise be opening five separate screens to confirm.

Then there are the lines, and the lines are where it gets good. Thick lines are real relationships. Actually established, actually recorded in the platform. Dotted lines are pseudo relationships, which is Lens telling you "these two aren't formally related, but they'd stitch together on identity anyway."

Hover a dotted line and it names the namespace doing the joining. That distinction matters more than it sounds like it should. Real and inferred relationships behave very differently when you're planning a build, and every other view of your sandbox blurs them together into nothing.

The arrowheads carry cardinality. A fan shape (the classic crow's foot) means many rows on that side can match one row on the other end. Plain arrowheads on both ends means strictly one-to-one.

Canvas view: is the diagram, and it's fully interactive in the ways you'd hope. Scroll or pinch to zoom, drag empty space to pan, drag a card to move it somewhere that makes more sense to you. Double-click empty space to flip between "fit the whole thing on screen" and "zoomed in far enough to actually read." There are buttons at the bottom for both if you prefer clicking.

Two things I use constantly.

The first is line selection. Click any line, thick or dotted, and it lights up while every other line on the canvas grays out. In a sandbox with forty schemas the diagram gets busy fast, and being able to isolate one connection so it reads cleanly from end to end is the difference between "I think those are related" and "yes, that joins on that, one to many, here's the field." Click it again or click empty space and everything comes back.
The second is Show all attributes on any card. Cards only show key attributes by design, otherwise you'd be reading a wall. Click that button and the schema's full attribute list opens in the right side panel, with its own search box. So the canvas stays readable and the detail is always one click away.

When you need to take the picture somewhere else, you can download the whole canvas as a high-resolution PNG, or export it as a .drawio file that Lucid imports directly. That second one has saved me more than once. Architecture reviews want a diagram in their tool, not a screenshot of mine.

Table view: shows the exact same schemas as a flat, sortable spreadsheet. Same data, completely different job.

Every schema is one row, with its title, class, whether it's profile-enabled, the schema ID, the field count, and then the columns that usually take the longest to dig up by hand: primary identity, identity, primary key, relationship key, version descriptor, timestamp descriptor. All of it side by side.

There's a search box, and clicking any column header sorts by it.

The count up top shows filtered against total, so you always know how much of the sandbox you're currently looking at. And there's an Export table button that drops the whole thing into Excel. Canvas is how you understand a sandbox. Table is how you answer a question about it. "Which schemas are profile-enabled?" Sort that column. "Which ones have no primary identity set?" Sort that one and look at the blanks. "How many fields is that schema really carrying?" It's right there.

This earns a regular spot in your workflow.

A few situations where it pays for itself immediately.

Walking into a sandbox you didn't build. Twenty minutes with the canvas gets you further than an afternoon of clicking through schema definitions. You come out knowing what the sandbox is for.
Before you build anything that joins data. The dotted lines are the quiet win here. Seeing which schemas would stitch on identity, and on which namespace, before you commit to a design saves the rework where you discover the join you assumed doesn't exist.
Auditing. Export the table, sort by whatever you're checking, and you have a real list. Schemas missing descriptors, schemas that were never profile-enabled, near-duplicates nobody cleaned up. These are the things that quietly cause problems six months later.
Handing work off. A PNG, a Lucid diagram, and a spreadsheet is a genuinely decent documentation package, and you got it in about two minutes instead of drawing it yourself.
Catching drift. Refresh it every so often. Sandboxes accumulate. New dotted lines show up. Schemas appear that nobody mentioned. It's a cheap habit that surfaces expensive surprises early.

The thing I'd actually push on: open this at the start of a piece of work, not at the end when you're documenting what you did. The ERD is most valuable as the thing that tells you what you're walking into.

Next in the series: the Source Dataflow tab, which answers the natural follow-up question. You now know how your schemas relate. Where is the data in them actually coming from?

Try Lens

Need Expert Help Mastering Your CDP Strategy?

At Shiftlytic, we specialize in Customer Data Platform (CDP) architecture, helping brands like yours consolidate fragmented data from website interactions, CRM systems, and offline sources into a unified 360-degree customer profile. We focus on turning dormant data into actionable insights that fuel real-time personalization and seamless omnichannel journeys.

Don’t let the technical complexity of cloud migration, the limitations of legacy batch processing, or the overhead of duplicate data storage stall your innovation. Whether you are exploring the modular flexibility of a Composable CDP integrated with your existing warehouse or implementing a full-stack solution like Adobe Experience Platform, we ensure your data integrity is maintained through robust cleansing and normalization.

Contact us today to schedule one free consultation and ensure your CDP ecosystem is accurate, scalable, and fully optimized. Let’s turn your customer data into a competitive advantage together