A local list in Pega UI provides a predefined set of values for UI elements without the overhead of dynamic retrieval or translation. It’s ideal for simple, fixed data. Compare it to prompt lists and lookup tables to see when a straightforward, non-localized set of options fits best.

Multiple Choice

Which configuration would you choose for a static list that does not require localization?

The most suitable configuration for a static list that does not require localization is a local list. A local list allows you to create a predefined set of values that can be displayed as options in a user interface without the overhead of dynamic retrieval or internationalization features. Local lists are specifically designed to support cases where the values are fixed and the context or application does not require translation into different languages. This makes them an ideal choice for situations where the information is simple and static in nature, providing a straightforward way to manage and present values to users. In contrast, other options, such as prompt lists and lookup tables, are typically used in different scenarios. Prompt lists may involve dynamic data retrieval or require additional configuration for user interaction. Field values, while useful for single-value selections, may not offer the same level of structured multi-value options as a local list. Therefore, when you need a static list with straightforward requirements, a local list is the best configuration choice.

Choosing the Right Static List in Pega UI: Why a Local List Often Fits Best

When you’re designing a user interface in Pega, you want the options you present to users to be clear, stable, and easy to manage. If your list of choices is static—unchanging over time and not tied to translations—the decision about how to configure that list matters less for performance and more for maintainability. In many cases, a local list ends up being the most sensible choice. It keeps things simple, predictable, and well within the scope of what your application needs.

Let’s unpack what makes a local list so appealing, and then contrast it with a few other configurations you might encounter. By the end, you’ll have a practical sense of when to lean on local lists and when another approach might be more appropriate.

What a Local List actually does

A local list is a predefined collection of values that lives in the UI layer. Think of it as a ready-made menu of options you can display to the user without pulling data from external sources or invoking any special localization logic. The values are there, they’re stable, and they’re ready to present in dropdowns, radio groups, or checklists.

Key benefits of a local list include:

  • Predictability: The values don’t change unless you explicitly modify them in the UI rules.

  • Simplicity: There’s no need to configure data sources, caches, or localization rules.

  • Speed: Since there’s no fetch from a server or a dynamic computation, rendering is fast and straightforward.

  • Maintainability: For a small, fixed set of choices, keeping the list in the UI rules makes it easy to review and update.

Picture this: you have a form that asks users to select their preferred contact method. The options are straightforward—Email, Phone, and Postal Mail. These choices don’t vary by locale, and there’s no reason to pull them from a dynamic source. A local list gives you a neat, compact container for those values, with all the benefits above.

Why not a local list for every scenario?

Of course, there are perfectly good reasons to choose other configurations depending on the context. Local lists shine when the values are truly static and locale-neutral. But what about situations where you’ll someday need multiple languages, or where the list could change based on business rules? In those cases, you might look at alternatives that offer more flexibility.

A quick tour of the alternatives

  • Prompt lists: These are often used when the values come from a dynamic source or depend on user actions. They can involve data retrieval, business rules, or conditions that tailor the list to what the user is doing in the moment. If you foresee variability, a prompt list can be a good fit, provided you’re comfortable with the extra configuration and the possibility of real-time data fetches.

  • Field values: This approach can work well when you’re pairing a single value with a field or when you have a compact, fixed mapping that’s tightly bound to a single field. It’s handy for situations where a one-to-one relation makes sense and you don’t need a broader set of options.

  • Lookup tables: Think of these as the more dynamic cousins. They live in data tables and can be used to drive lists that change depending on the context, user profile, or external data feeds. If your list needs to adapt—perhaps to reflect permissions, regional variations, or evolving business rules—a lookup table offers robust flexibility.

The takeaway here is not that one approach is always better, but that each has a role. For a straightforward, static, locale-agnostic list, a local list offers a clean, low-friction path. For anything that requires adaptation, look to a broader mechanism that can grow with your application's needs.

A practical lens: when a local list makes sense

  • The values are fixed and simple: You’re not juggling dozens of choices, nor do you anticipate changes in the near term.

  • Localization isn’t a factor: Everyone sees the same set of options, no translation layer needed.

  • Performance matters: You want to minimize calls, latency, and complexity in the UI.

  • Maintenance should be easy: A quick tweak in the UI rules should be enough to adjust the options.

In these scenarios, a local list is a quiet workhorse—reliable, unobtrusive, and easy to reason about. It keeps the UI clean and predictable for developers, content owners, and end users alike.

A small sanity check: alignment with UX goals

Even though the local list is a solid choice for static, non-localized content, it’s worth pausing to consider the user experience. Does the list convey meaning clearly? Are the labels succinct and accessible? If your options are self-explanatory, a local list can feel almost invisible in the best possible way—users scan the choices, pick one, and continue without a second thought.

Sometimes, a tiny wording tweak goes a long way. If you’re naming values, aim for consistency in capitalization, avoid jargon, and consider the user’s mental model. A well-crafted local list not only works smoothly but also feels intuitive.

Design tips to maximize the local list’s effectiveness

  • Keep the count reasonable: If you’re listing a long set of choices, consider grouping or reorganizing them to reduce cognitive load. A long, unwieldy list can frustrate users, even if it’s static.

  • Use clear labels: Short, plain-language terms beat anything abstract. If a label needs a bit of explanation, you can add help text nearby, not on the option itself.

  • Align with form flow: Place the list where it makes sense in the sequence of inputs. A logical order helps users answer quickly and confidently.

  • Validate on the UI: If a field requires a selection, ensure the UI clearly shows that a choice is needed, with helpful error messages if nothing is selected.

  • Consider accessibility: Ensure keyboard navigation works smoothly, and screen readers can announce options in a sensible order.

Subtle digressions that still connect back

While we’re on the subject of static lists, you might notice how many decisions in UI design hinge on a simple tension: flexibility versus simplicity. It’s a recurring dance in software, where you weigh future-proofing against the joy of getting something done without a lot of drama. The local list embodies the beauty of restraint. It’s not flashy, but it’s dependable. And in teams where speed and clarity matter, that reliability matters more than a glossy feature that’s overkill for the current needs.

If you’ve ever been tempted to over-engineer a UI, remind yourself of the value of restraint. A small, well-contained solution can save you hours later when requirements shift—without throwing complexity into your codebase today. It’s like choosing a compact toolkit for a home repair project: you don’t need the entire hardware store to fix a squeaky door.

A word on maintenance philosophy

Maintaining a static, locale-agnostic list isn’t about resisting future change; it’s about choosing the right tool for the job now and keeping flexibility where you really need it. You can always convert a local list to a more dynamic option later if business needs evolve. The key is to design with clear boundaries: decide what stays fixed, what can flex, and how you’ll migrate if the moment comes.

What to watch for down the road

  • Emerging localization needs: If you begin to support multiple languages or culture-specific displays, you’ll likely reassess whether the local list still fits, or if a lookup table or a dynamic source should be used.

  • Data governance considerations: Even fixed lists should be documented. A short note about why values are static helps teammates understand the choice later, especially if product scope changes.

  • UI consistency: As your app grows, keeping a consistent approach to lists across forms helps users learn the interface quickly. A local list can be a cornerstone of that consistency, as long as you apply it thoughtfully.

Bringing it together

In the end, the choice to use a local list for a static, non-localized set of values is about finding the simplest, most reliable path to a good user experience. It strips away unnecessary layers—no data fetches, no localization hooks, no fuss—so users can focus on what truly matters: making a selection and moving forward.

If you’re shaping a form where the options are fixed and language isn’t a concern, go with a local list. It’s a quiet, steady enabler that respects both the user’s time and the developer’s sanity. And who doesn’t want a design choice that honors both?

A final thought: sometimes the most elegant UI decisions are the ones that don’t shout. A local list isn’t flashy, but it doesn’t need to be. It just works—reliably, predictably, and with a touch of understated finesse. That’s enough to make a user’s day a little bit easier, one click at a time.