Explore how to shape data from an Integration Procedure for a card layout in OmniStudio. See why using a top-level array of Case objects with a nested Contact object supports repeating rows and related details, while flattening fields or using XML can hinder binding and reuse. Understand how clean separation of collections and single-valued groups makes UI binding smoother and more scalable.

Multiple Choice

The card layout uses an integration Procedure as a data source. Which JSON structure best supports this layout?

In a card layout that pulls data from an Integration Procedure, the data shape should naturally separate repeating rows from single, related details. Repeating items are provided as an array of objects, while related single-valued fields are grouped under their own object so the layout can bind to both sections cleanly. The best structure matches this pattern: a top-level Case array where each item has Number and Subject, plus a Contact object containing Name and Phone. This lets the card render multiple case entries as a list and show the contact details in a separate block without flattening everything into one level. The other options fall short for typical card binding. Flattening contact fields into separate top-level properties (as in the second choice) can complicate binding a distinct contact section. Using a top-level array with a single object (as in the third choice) doesn’t clearly represent multiple cases as a reusable collection. The last option uses XML instead of JSON, which isn’t compatible with a JSON-based Integration Procedure data source.

When building a card layout in OmniStudio, data is king — and the shape of that data determines how smoothly your UI binds to it. The goal is simple on the surface: you want a clean separation between multiple repeating items (like a list of cases) and single, related details (like a contact card). Get that right, and the card hums. Get it wrong, and you end up with brittle bindings, kludgy templates, and a lot of manual data wrangling. So let’s talk about how to structure JSON data for a card layout that uses an Integration Procedure as its data source.

A familiar pattern you’ll see in real-world apps

Imagine a support dashboard on a CRM-like front end. You want two things on that screen:

  • A list of cases, where each case shows its number and subject.

  • A single contact block that shows the name and phone number of the person tied to those cases.

This combination isn't just aesthetically pleasing; it’s a practical division of concerns. The repeating portion (the list of cases) is best represented as an array of objects. Each item in that array can render on its own, and the collection can grow without breaking the layout or the binding logic. The single-valued portion (the contact) benefits from being its own nested object, so you can bind a dedicated “Contact” section without flattening everything into one flat dictionary.

Why a top-level array plus a nested object works well

Let me explain with a mental model you’ve probably used when organizing notes or a file cabinet. The cabinet has folders (the repeating items) and a label card (the single-valued metadata). If you toss every piece of information into one flat pile, you lose the mental map of what goes where, and the UI has to guess. But if you group related items together — a Case list where each Case has Number and Subject, and a separate Contact object with Name and Phone — you give the UI a natural map to bind against.

That clarity matters when a card layout needs to display multiple cases in a neat list while keeping the contact block cleanly separated. The data shape becomes a map for the rendering engine: you iterate the Case array to render a list, and you bind the Contact object to its panel. The separation isn’t just tidy; it’s pragmatic for reuse and future extension.

What the JSON should look like in practice

The most straightforward structure that supports both concerns looks like this:

{

"Case": [

{ "Number": "324423423423", "Subject": "Cannot tack our order" },

{ "Number": "324423423423", "Subject": "Cannot tack our order" }

],

"Contact": {

"Name": "Lanne Tomlin",

"Phone": "324242324"

}

}

Let’s break down why this works so well.

  • Case is an array of objects. Each object has a Number and a Subject. This makes it easy to render a repeating list — as many Case items as there are — without any extra parsing or transformation.

  • Contact is a single object with Name and Phone. The card can bind to a dedicated contact section, pulling in the two fields without flattening everything into top-level properties.

  • The separation is explicit. If you later need to add more fields to each case (or to the contact), you can extend the respective substructures without touching the other side of the data. That’s a win for maintainability.

A quick contrast with other structures

Seeing the other options helps reinforce why the top-level array plus a nested object is a natural fit.

  • Flattened top-level fields for the contact (e.g., "ContactName" and "ContactPhone") can complicate the binding for the contact segment. The card would have to know which fields belong where, and adding more contact details risks a naming puzzle across the data model.

  • A top-level array that wraps everything in a single object (e.g., an array with one case object) makes it awkward to represent multiple, distinct cases as a reusable collection. The UI would need extra logic to treat the first item as a list and manage the rest differently, which isn’t elegant.

  • XML-like structures (e.g., a root with XML tags) don’t harmonize with a JSON-driven Integration Procedure data source in this setup. The card layout engines typically expect JSON, and mixing formats creates friction.

A gentle detour into binding realities

If you’ve ever built a card in a low-code environment, you know binding is where the rubber meets the road. A well-formed data shape reduces the number of binding expressions you must write and keeps the template code straightforward. With the JSON pattern above, your card’s bindings become intuitive:

  • Bind the repeating region to the Case array. Each row maps to an item, showing Number and Subject.

  • Bind the contact block to Contact.Name and Contact.Phone. Those fields populate a dedicated panel, preserving the visual separation from the list.

This approach also scales gracefully. Want to show additional per-case details, like Status or CreatedDate? Just add those properties to each Case object. Want to add an email or alternate contact method? Extend the Contact object. The UI doesn’t need to be rewritten; the data schema simply grows with the needs.

Practical tips you can actually use

  • Keep the repeated items clearly nested. Don’t flatten the list into a single object. It makes rendering logic bloated and fragile.

  • Use meaningful field names. Case becomes an obvious container for Number and Subject, and Contact becomes the clear home for Name and Phone. Clarity saves time when you or teammates revisit the layout later.

  • Think about nullability. If a contact’s phone isn’t always available, consider providing a placeholder or null-safe binding so the UI gracefully handles missing data.

  • Plan for future extensibility. If you anticipate grouping more related fields under Case or Contact, design the nesting with an eye toward growth rather than a quick hack to squeeze data into a fixed shape.

From concept to a polished UI

The beauty of this data pattern isn’t just theoretical. It translates into cleaner templates, fewer binding edge cases, and a card that behaves like a well-tuned instrument. When the Integration Procedure returns data in this structure, the card layout can present a tidy, readable view: a central list of cases that can grow without bound, and a separate, stable contact block that anchors the entire presentation.

A few more thoughts that spark good design sense

  • Consistency is your friend. If you’re handling more sections (for instance, a list of activities or related notes), maintain the same principle: a top-level array for the repeating rows, and nested objects for single-value groups. The mental map stays intact.

  • Documentation still matters. Even if you’re fluent in JSON structures, a quick note about how the data is organized helps future you and teammates avoid unnecessary back-and-forth. A short schema sketch on the side can be a lifesaver.

  • Visualize the end result. Before you wire anything up, sketch the card sections and how they align. It’s a quick exercise that yields dividends when you translate the sketch into bindings.

A final reflection

In UI development, the shape of your data often dictates the rhythm of your code. When the data mirrors a real-world structure — a clean list of repeating items alongside a clear, related single block — the card not only looks good, it behaves predictably. It’s a small but meaningful win: a JSON structure that respects the natural separation between “many things” and “one thing,” letting the interface breathe and the user focus on what matters.

If you’re assembling a card for a dashboard or a quick-view panel, start with that two-part data design: an array of Case items for the list, and a nested Contact object for the details. It’s a pattern you’ll end up returning to again and again, because it simply works — neat, maintainable, and ready to evolve with your app. And when your screen glides into place with that effortless binding, you’ll feel that familiar click of a job well done.