Deep Linking in Power Apps Canvas Apps // Chris Worth

Introduction

Deep linking has completely transformed how our organization uses Power Apps. Before implementing this technique, users had to navigate through multiple screens to reach their destination—often abandoning the app out of frustration. Now, with a single click on an email link or Teams message, they land exactly where they need to be.

Deep linking in Power Apps Canvas apps allows users to navigate directly to specific screens or pass parameters to customize their experience. This functionality is essential for creating seamless, user-friendly apps that integrate well with your broader business processes.

Why Deep Linking Matters

I first discovered the power of deep linking when building an equipment inspection app for our field technicians. Instead of forcing them to search through hundreds of items, we created QR codes that opened the app directly to the relevant equipment’s details screen.

Effective deep linking brings several key benefits:

Improved User Experience: Users reach their destination with a single click
Higher Adoption Rates: Reduced friction leads to increased app usage
Better Integration: Your app becomes part of a cohesive ecosystem
Time Savings: Users spend less time navigating and more time on actual tasks

In one case, we reduced the time to complete an approval process from several minutes to just seconds by implementing deep links from notification emails directly to the approval screen.

Key Concepts in Deep Linking

App URL: Every Power Apps Canvas app has a unique URL, which can be extended with query parameters to enable deep linking.

   https://apps.powerapps.com/play/<AppID>

Query Parameters: Added to the app URL to specify actions or screens.

   https://apps.powerapps.com/play/<AppID>?Page=Details&ItemID=123

Param() Function: Retrieves values from the query parameters inside the app.

Implementing Deep Linking in Power Apps

Step 1: Use the `App.StartScreen` Property

The App.StartScreen property determines the initial screen when the app opens. It’s a better alternative to using App.OnStart for navigation.

App.StartScreen = Switch(
    Param("Page"),
    "Details", DetailsScreen,
    "Settings", SettingsScreen,
    HomeScreen
)

I’ve found that using App.StartScreen is significantly more reliable than trying to use Navigate() functions in App.OnStart, which can lead to timing issues and inconsistent behavior.

Step 2: Retrieve Parameters Using `Param()`

Set(itemID, Param("ItemID"));

When implementing this in our asset management app, I learned to always check for blank values:

If(
    !IsBlank(Param("ItemID")),
    Set(itemID, Param("ItemID")),
    Set(itemID, "")
)

Step 3: Build Logic Based on Parameters

If(!IsBlank(itemID),
    Filter(ItemsDataSource, ID = itemID),
    ItemsDataSource
)

In our project management app, we used this pattern to load specific tasks:

Set(
    currentTask,
    If(
        !IsBlank(Param("TaskID")),
        LookUp(Tasks, ID = Param("TaskID")),
        Blank()
    )
);

Real-World Implementation Examples

Approval Process Integration

For our expense approval system, we send emails with deep links that take approvers directly to the specific expense record:

"Please review this expense report: https://apps.powerapps.com/play/e123456-abcd-7890?Screen=Approval&ExpenseID=" & ExpenseID

Inside the app, we handle this with:

App.StartScreen = If(Param("Screen") = "Approval", ApprovalScreen, HomeScreen);

// In ApprovalScreen's OnVisible
Set(
    currentExpense,
    LookUp(Expenses, ID = Param("ExpenseID"))
);

This reduced our approval time by 70% since managers could immediately see and act on requests.

QR Code Asset Management

For field technicians, we generated QR codes containing deep links to equipment details:

"https://apps.powerapps.com/play/e123456-abcd-7890?Screen=AssetDetails&AssetID=" & AssetID

Technicians simply scan the QR code on the physical equipment to access its maintenance history, documentation, and service forms.

Status Update Reporting

We integrated deep links with Power Automate to send regular status update reminders:

"Please update your project status: https://apps.powerapps.com/play/e123456-abcd-7890?ProjectID=" & ProjectID & "&Action=StatusUpdate"

The app handles multiple parameters:

App.StartScreen = Switch(
    true,
    !IsBlank(Param("Action")) && Param("Action") = "StatusUpdate", StatusUpdateScreen,
    !IsBlank(Param("ProjectID")), ProjectDetailsScreen,
    HomeScreen
);

Creating Deep Links

Base URL: Find your app’s URL from the Power Apps portal
Add Parameters: Append query parameters:

   https://apps.powerapps.com/play/<AppID>?Page=Details&ItemID=456

For production use, I recommend creating a function to generate consistent deep links:

BuildAppLink = 
Function(screenName, itemID,
    "https://apps.powerapps.com/play/e123456-abcd-7890?Screen=" & screenName & 
    If(!IsBlank(itemID), "&ItemID=" & itemID, "")
)

Troubleshooting Common Issues

Parameters Not Being Passed Correctly

Issue: Your app doesn’t receive the expected parameters.

Solution:

Check URL encoding—spaces and special characters need proper encoding
Verify parameter case sensitivity
Test with hardcoded parameters to isolate the issue

App Opens but Doesn’t Navigate to the Correct Screen

Issue: The app opens but stays on the default screen.

Solution:

Verify your App.StartScreen formula is correct
Add a debugging label to display Param("YourParam") values
Ensure the screen reference in your Switch statement matches your actual screen names

Deep Links Working in Browser but Not in Mobile App

Issue: Links work when tested in a browser but fail in the Power Apps mobile app.

Solution:

Ensure you’re using the proper URL format for mobile
Check if your app is available offline—this can affect parameter handling
Test with the latest version of the Power Apps mobile app

I once spent hours debugging why parameters worked on desktop but not mobile, only to discover our URL had spaces that weren’t properly encoded!

Best Practices

Use App.StartScreen instead of App.OnStart for navigation

This was a hard-learned lesson for me. Using Navigate() in App.OnStart is unreliable and can cause screen flickers.
Implement default navigation when no parameters are provided

Always have a fallback screen for when users access your app without parameters.

Validate parameters and handle invalid values gracefully

I always include validation code:

If(
    !IsBlank(Param("ItemID")) && !IsNumeric(Param("ItemID")),
    Notify("Invalid item ID provided", NotificationType.Error)
)

Test across browsers and the Power Apps mobile app

Parameter handling can behave differently across platforms.
Avoid exposing sensitive data in URLs

Use IDs rather than actual data values in your parameters.
Document your deep linking schema

I maintain a simple table with all supported parameters and their expected formats.
Create shortened URLs for complex deep links

For links that will be shared widely, consider using URL shorteners to improve usability.

Security Considerations

When implementing deep linking, always consider security implications:

Don’t bypass authentication

Deep links still require proper authentication to the Power Apps environment.
Validate parameter inputs

Always validate that the parameters provided match expected patterns before using them.
Implement row-level security

Ensure users can only access records they have permission to view, regardless of the parameters passed.
Don’t include sensitive information in URLs

URLs can be logged in browser histories and server logs.

Conclusion

Mastering deep linking in Power Apps is a journey worth taking. The techniques we’ve covered in this guide have helped me create more integrated, user-friendly, and efficient apps—and they can do the same for you.

Remember these key points:

Use App.StartScreen for reliable navigation control
Always validate parameters and provide graceful fallbacks
Test your deep links across all platforms and devices
Consider security implications when designing your parameter scheme

As you implement these practices in your own apps, you’ll likely encounter unique challenges specific to your app’s structure and business requirements. Don’t hesitate to experiment and adapt these techniques to your specific needs. The Power Platform community is also an excellent resource for troubleshooting and ideas.

What’s your next step? I recommend identifying one high-friction navigation path in your existing app that could benefit from deep linking. Even implementing a single deep linking scenario can dramatically improve the user experience and drive adoption.

Introduction

Why Deep Linking Matters

Key Concepts in Deep Linking

Implementing Deep Linking in Power Apps

Step 1: Use the App.StartScreen Property

Step 2: Retrieve Parameters Using Param()

Step 3: Build Logic Based on Parameters

Real-World Implementation Examples

Approval Process Integration

QR Code Asset Management

Status Update Reporting

Creating Deep Links

Troubleshooting Common Issues

Parameters Not Being Passed Correctly

App Opens but Doesn’t Navigate to the Correct Screen

Deep Links Working in Browser but Not in Mobile App

Best Practices

Security Considerations

Conclusion

Step 1: Use the `App.StartScreen` Property

Step 2: Retrieve Parameters Using `Param()`