In OutSystems, a Button’s On Click Destination can point to a Screen, a Client Action, or an External Site. Blocks are reusable components used inside screens and don’t represent navigational targets. That’s why a Block can’t be chosen as the On Click Destination; it’s not a view or action to navigate to.

Multiple Choice

Which option cannot be set as the On Click Destination for a Button in a Screen?

The option that cannot be set as the On Click Destination for a Button in a Screen is Block. In OutSystems, the On Click Destination of a Button is intended to specify the action that will occur when the button is clicked. This action can involve navigating to a new screen, executing a client-side logic via a Client Action, or redirecting to an external site. Blocks are used to encapsulate reusable components and do not serve as navigational destinations. They are typically incorporated into screens rather than acting as independent navigational targets. Therefore, it would not be appropriate to set a Block as an On Click Destination since it does not lead to an alternative view or action that a Button is designed to perform. In contrast, setting a Button to navigate to a Screen allows users to go to another defined interface, executing a Client Action provides specific, reusable logic on the client-side, and directing to an External Site opens an entirely different web address, all of which are actions consistent with a Button's functionality.

Buttons are the little workhorses of a reactive web app. They’re the sparks that set your UI in motion: a click that lights up a new screen, runs a tidy bit of client-side logic, or whisk you off to an external site. In OutSystems, the On Click Destination of a Button is where you decide what magic happens after a user taps that button. Understanding what can and cannot be a destination helps you design smoother, more predictable journeys through your app.

Let’s unpack the options and why one of them simply doesn’t fit the role.

What the On Click Destination can be (and why)

Screen

Think of a Screen as a real destination, like a room you walk into. It makes total sense to connect a Button’s click to navigating to another screen. Users might click a “Next” button to continue a form, or a “View Profile” button to hop over to a user-details screen. In practice, routing to a Screen is a core navigation pattern. It’s direct, user-friendly, and aligns with how you structure the app’s flow.

Client Action

A Client Action is a piece of reusable client-side logic. It’s the perfect spot for small, fast operations that don’t require a round trip to the server. For example, you might want to validate some fields on the fly, toggle a UI element, or set a local variable that changes what the user sees next. Hooking a Button to a Client Action keeps things snappy and responsive, which is especially valuable for lightweight interactions that don’t justify a server call.

External Site

Redirecting to an External Site is another familiar destination. A button can open a new URL, guiding users to a related resource, support page, or partner site. Just be mindful of user expectations—opening a new tab vs. navigating in the same window can impact the user’s sense of context. If you want a new tab, you can usually configure that behavior easily in the action.

Block

This is where the waters get murky. Blocks in OutSystems are powerful as reusable UI components. They encapsulate structure, styling, and sometimes behavior, and they’re great for composing complex screens. But they’re not navigational destinations. A Block isn’t a view you can “go to” in the sense of screen-to-screen navigation, and it isn’t a standalone action you can execute in isolation. Because a Button’s primary role at the click is to drive a change in the app’s state or the user’s location, pointing to a Block would be more about embedding content than triggering a navigational or logical outcome. That’s why you don’t set a Block as the On Click Destination.

Let me explain with a simple mental model. If you think of your app as a city, a Screen is a different neighborhood you can walk into. A Client Action is the little brainy shortcut that keeps you moving with smarter traffic rules on the streets. An External Site is a faraway landmark you might visit. A Block, though incredibly useful, is more like a building block inside a neighborhood—the furniture and fixtures inside it are part of the experience, but you don’t “go to” the Block itself.

How to design with intention

Navigation first, then logic

If your goal is to move the user from one view to another, the Screen destination is your friend. It’s the clearest signal of intent: you’re presenting new content, a new form, or a new stage in a flow. Before you bolt on a Client Action for a quick check, pause and ask: does this require a full screen change, or can I handle the interaction in the current context? If it’s a simple step in a sequence, Screen-to-Screen navigation often reads more naturally and preserves the user’s mental model.

Lean into Client Actions for speed and cohesion

Client Actions shine when you want to keep the experience snappy. They’re great for immediate UI feedback, minor validations, or manipulating local state without a server trip. If you’re tinkering with a UI element, like toggling a panel, adjusting a slider’s value, or showing/hiding a message, a Client Action is usually the right tool. It keeps things responsive and prevents unnecessary latency from network chatter.

External Site with care

External navigation is a good option when you genuinely need to bring users to a resource outside your app. It’s essential to consider user expectations: should the link open in a new tab, or should it replace the current view? Consistency matters—if you’ve historically opened external links in a new tab, keep that pattern. And if the external site is part of a trusted partner, a light, informative cue (like an icon) can reassure users about what’s coming next.

Blocks aren’t for navigation

Because Blocks are about reusable UI pieces, they belong in a different layer of design. They’re fantastic for building consistent interfaces, but they don’t represent a “destination” in the sense of moving to a new screen or initiating a standalone action. When you’re wiring up a Button, reserve Blocks for content composition inside the screen or within a reusable component. If your instinct is to poke at a Block as the outcome of a click, pause and reframe: what user-facing change should happen instead? A screen change, a client action, or an external redirect typically fits better.

Practical patterns you’ll see in real apps

  1. A multi-step form
  • Button on Step 1 navigates to Step 2 (Screen).

  • The next button may also trigger a small Client Action that saves a local draft in memory to prevent data loss if the user navigates away, then proceeds to Step 2.

  1. A responsive UI toggle
  • A Button toggles a settings panel via a Client Action that flips a boolean variable, showing or hiding the panel without leaving the current screen. It’s instant, fluid, and keeps the user anchored where they are.
  1. A help or support path
  • Button opens an external help center, perhaps in a new tab or a modal, depending on the user’s context. It’s a perfect fit for External Site.
  1. A dashboard drill-down
  • A Button on a card navigates to a detailed Screen that presents richer data for the selected item. You gain the benefit of consistent navigation patterns and a crisp line of sight in the app’s structure.

A few design considerations to keep everything tidy

  • Maintain a clear visual cue for destination type

If a Button leads somewhere dramatic (a new screen) or something subtle (a tiny UI tweak), users should sense that difference. Use subtle but consistent visuals—icons, label choices, or micro-interactions—that align with the outcome. A “Go to detail” action might be styled differently from a lightweight “Show tips” action.

  • Don’t overburden a single Button

If you find yourself juggling multiple outcomes from one Button, it might be a sign you should split it into two. Clear, singular intents are easier to test, reuse, and maintain. It’s better to have a Button labeled clearly for one outcome than a mash of conditional logic behind a single click.

  • Leverage reusable assets wisely

Blocks are superb for standard UI patterns you drop into many screens—headers, footers, card layouts, or a consistent data list. Keep them focused on appearance and local behaviors. If you need to orchestrate a navigation or a cross-cutting action, separate it from the Block to avoid entangling structure with behavior.

  • Plan for accessibility

Keyboard navigation and screen reader compatibility matter. Make sure the destination—whether Screen, Client Action, or External Site—has accessible labels and predictable focus behavior. If a Button’s action requires additional context, consider tooltips or ARIA attributes so users with assistive tech aren’t left guessing what happens next.

Think in terms of user journeys, not just technical pieces

At the end of the day, the On Click Destination is about guiding the user through a coherent experience. Screens move the narrative forward; Client Actions handle the moment-to-moment logic; External Site links open doors to off-app resources. Blocks, meanwhile, are the scaffolding that makes your UI feel polished and consistent—beautiful, but not a destination in itself.

If you’re ever unsure which destination fits, start with the user’s goal. Do they want to see new information on a different page? Then Screen. Do they need a quick, local tweak? Then Client Action. Do they need a handoff to an outside resource or partner? External Site. And if your instinct wants to push a Block as the endpoint, pause and reframe: what should the user experience after the click be? The answer will usually steer you toward one of the other destinations.

A final thought

Building interfaces is a bit of a balancing act—between speed and depth, between reusability and clarity, between what’s inside the app and what lies beyond it. OutSystems gives you a clean map for how to connect user intentions with concrete outcomes. By thinking in terms of navigations, local logic, and external doors, you’ll craft experiences that feel intuitive, responsive, and thoughtfully structured. And that sense of flow—where a click almost nudges you forward with purpose—that’s really what great reactive web development is all about.