How to Get Current Screen Name in Power Apps [All Methods Explained]

If you’ve been building canvas apps in Power Apps for a while, you’ve probably hit this question at some point: “How do I know which screen the user is currently on?”

Maybe you want to show a dynamic title in a header. Maybe you’re building a shared navigation component and want it to highlight the active screen. Or maybe you just want to debug something and see where your app is at any given point.

Whatever the reason, this tutorial covers every practical way to get the current screen name in Power Apps, with real examples you can use right away.

What “Current Screen Name” Means in Power Apps

Before jumping into formulas, let me quickly clarify what we’re talking about.

Every screen in a Power Apps canvas app has a Name — the one you see in the Tree View on the left side in Power Apps Studio. For example: HomeScreen, DetailsScreen, LoginScreen, and so on.

When your app is running, only one screen is visible at a time. Power Apps tracks that screen through the App object, and that’s exactly where we pull the current screen name from.

Get Current Screen Name in Power Apps

There are three main approaches:

1. Using App.ActiveScreen.Name — the cleanest, built-in method
2. Using a global variable to track the screen name manually
3. Using a component with a custom input property (great for shared headers)

Let me walk through each one.

Method 1: Using Power Apps App.ActiveScreen.Name

This is the simplest and most direct way. Power Apps has a built-in property on the App object called ActiveScreen. It returns a reference to whichever screen is currently visible — and you can pull the .Name from it to get a text value.

The formula:

App.ActiveScreen.Name

Where to use it:

Put this in the Text property of a Label control on any screen. When your app runs, that label will automatically show the name of the current screen.

Here’s a quick example. Say you have a label And you want it to always show the current screen’s name:

• Select the label
• Go to the Text property in the formula bar
• Type: App.ActiveScreen.Name

That’s it. No variables, no extra setup.

You can also use it for comparisons:

App.ActiveScreen = HomeScreen

This returns true if HomeScreen is currently active, and false Otherwise, this is really handy when you want to conditionally show or hide something based on which screen is active.

For example, if you have a Back button and you only want it visible when the user isn’t on the home screen:

Visible = App.ActiveScreen <> HomeScreen

One important note: App.ActiveScreen.Name reads the screen name as it’s defined in the Tree View of Power Apps Studio — not a custom title you’ve assigned. So if you named your screen Screen3, that’s what you’ll see. Good naming conventions matter here, which I’ll touch on at the end.

Method 2: Track Screen Name With Power Apps Global Variable

This method is older and more manual, but it’s still used in many apps — especially ones built before App.ActiveScreen was reliable or in complex apps where you need full control over the displayed title.

The idea: You set a variable (varScreenTitle) when the user navigates to a screen, and then display that variable in a label.

Step-by-step setup:

1. In App.OnStart, initialize the variable with your starting screen’s title:

Set(varScreenTitle, "Home")

2. On each button or navigation action that takes users to a new screen, set the variable before calling Navigate:

Set(varScreenTitle, "My Leave");
Navigate(MyRequest_Screen,ScreenTransition.CoverRight);

3. In your header labels Text property, reference the variable:

varScreenTitle

Why use this over Method 1?

A few reasons:

• You want to show a friendly display title (like “Employee Details”) instead of the actual screen name (DetailsScreen)
• You’re on an older app and App.ActiveScreen behaves unexpectedly
• You need the title to change dynamically based on context (e.g., “Edit Mode” vs “View Mode” on the same screen)

The downside is obvious — you have to remember to update the variable every single time you add a new navigation action. Forget it once and the title stays wrong. For small apps it’s manageable. For larger ones, Method 1 or Method 3 is cleaner.

Method 3: Use Power Apps Component With App.ActiveScreen.Name

If you’re building a real app with a consistent header across multiple screens, you don’t want to paste the same label on every single screen. That’s where components come in.

A component is a reusable UI block. You build it once, drop it on every screen, and it behaves the same everywhere. You can pass App.ActiveScreen.Name into it as a custom property, and the component displays it automatically.

Here’s how to set it up:

Step 1: Enable Components

Go to Settings → Upcoming features → Experimental and make sure Components is turned on. (In most recent versions of Power Apps, it’s already available by default.)

Step 2: Create a New Component

• In the Power Apps Tree View, go to the Components tab
• Click New component and rename it — something like cmpHeader
• Set the height to around 60 pixels (for a typical header bar)

Step 3: Add a Custom Input Property

• Click New custom property
• Name it: ScreenTitle
• Property type: Input
• Data type: Text
• Click Save

Step 4: Add a Label to the Component

• Insert a Text label inside the component
• Set its Text property to: cmpHeader.ScreenTitle

Step 5: Set the Default Value

On the component itself, go to the ScreenTitle property and set the default value to:

App.ActiveScreen.Name

Now, whenever this component is placed on a screen, it automatically reads and displays the name of the active screen. You didn’t have to do anything on the individual screens.

Step 6: Add the Component to Your Screens

Go to each screen, insert the cmpHeader component from the component library, and it just works.

If you want to override the default and show a custom title on a specific screen, simply change the ScreenTitle property on that instance:

"Employee Details"

That gives you flexibility — automatic names by default, manual overrides where needed.

Which Method Should You Use?

Here’s my honest take:

• Start with App.ActiveScreen.Name if you just need to show or compare the current screen. It’s zero setup and always accurate.
• Use a global variable if your app has custom, user-friendly screen titles that don’t match the technical screen names.
• Use a component if you have a shared header bar across many screens and want to keep things clean and maintainable.

Most modern Power Apps I build use a combination of Method 1 and Method 3 — components that pull App.ActiveScreen.Name by default, with manual overrides on screens that need a friendlier label.

Real-World Example: Dynamic Breadcrumb Navigation

Here’s a practical scenario. Say you want to show a breadcrumb at the top of every screen like: Home > Current Screen.

On a label in your shared header component, set the Text property to:

"Home > " & App.ActiveScreen.Name

If the user is on DetailsScreen, the label shows: Home > DetailsScreen

Want it cleaner? Use a variable approach and set the variable to "Employee Details" before navigating, then your breadcrumb shows: Home > Employee Details

One Thing That Trips People Up

A question I see in the Power Apps community a lot: “Why does App.ActiveScreen.Name always returns the same screen name even when I navigate?”

Here’s the deal — if you put App.ActiveScreen.Name in a label  Screen1 and you’re testing within Studio, you’ll always see Screen1 it because that label is on Screen1. The formula is always technically correct — it’s just that the label only renders when that screen is visible.

To properly test it, drop the label on every screen or use it inside a shared component. Then, as you navigate between screens, the value updates correctly.

A Quick Note on Naming Your Screens

Whatever method you choose, your screen names matter. If you’re relying on App.ActiveScreen.Name to display titles to users, names like Screen1, Screen2, Screen3 are not going to cut it.

Use descriptive names like:

• HomeScreen
• EmployeeListScreen
• NewRequestScreen
• SettingsScreen

This makes the formula output readable and saves you from having to build a separate mapping table just to translate screen names into something human-friendly.

Conclusion

Getting the current screen name in Power Apps is genuinely straightforward once you know where to look. The App.ActiveScreen.Name Property does most of the heavy lifting, and for anything more advanced — like shared headers or user-friendly titles — a variable or component approach fills the gap nicely.

The key takeaway: always name your screens properly from the start. It saves you a lot of retrofitting later.

Also, you may like:

• Power Apps Remove Function
• Create a Folder in SharePoint From Power Apps
• Power Apps Dropdown Show Only Unique Values
• Power Apps CountRows Function [Including the Delegation Fix]
• 51 Power Apps Interview Questions and Answers For Experienced Developers