I still remember when our field technicians were forced to revert to paper notes because their app couldn’t retrieve critical equipment details in a remote area. That day underscored a simple truth: offline functionality isn’t a luxury—it’s a necessity. From that moment, I was determined to ensure our Power Apps could stand on their own, even when the internet couldn’t.

In many real-world scenarios, reliable connectivity can’t be taken for granted. Whether you’re working deep in the backcountry or just dealing with spotty cell coverage, enabling offline capabilities in your Canvas Apps ensures users can continue working seamlessly. This article will show you how to build a Canvas app that keeps going offline, using the Power Apps functions SaveData and LoadData.

Why Offline Capabilities Matter

Offline functionality empowers users to:

  • Keep working uninterrupted when connections drop
  • Pre-load critical reference data before venturing into low-connectivity areas
  • Capture and store data locally to sync later
  • Eliminate the frustration of lost work due to network issues

After rolling out offline support in our inspection app, we saw a 70% reduction in data entry errors, saved technicians nearly an hour daily, and dramatically improved user satisfaction. In short, adding offline support directly impacts productivity and user trust in your app.

How SaveData and LoadData Work

The foundation of offline functionality in Canvas apps lies in two Power Fx functions: SaveData and LoadData. These functions let you cache data on the device so your app can use it without a network.

SaveData – Storing Data Locally

The SaveData function writes a collection to the device’s local storage:

SaveData(MyCollection, "MyLocalCache")

Here, MyCollection is the collection you want to save, and "MyLocalCache" is a unique name for your cached data.

Key points about SaveData:

  • It can only store collections (tables of records)
  • In web browsers, SaveData is limited to 1 MB of data
  • On mobile devices, the limit is based on available device storage
  • Data saved is not encrypted, so avoid caching extremely sensitive information

LoadData – Retrieving Cached Data

When you need to retrieve data from local storage, you use the LoadData function:

LoadData(MyCollection, "MyLocalCache", true)

This reads the locally stored data named "MyLocalCache" back into MyCollection. The parameters are:

  • MyCollection: The collection to load data into
  • “MyLocalCache”: The name/key you used when saving
  • true: (Optional) A boolean that suppresses errors if the cache doesn’t exist

The third parameter is typically set to true to avoid errors when the app runs for the first time (when no data is saved yet).

Using these functions alongside Connection.Connected (a boolean that detects network status), you can implement a robust offline experience.

Building an Offline-Capable App: Step-by-Step

Let’s walk through implementing offline capabilities in a practical way:

1. Planning Your Offline Strategy

Begin by identifying key data your app needs when offline:

  • Reference Data: Read-only information users might need to lookup (equipment specs, product catalogs)
  • User Input Data: Records users will create or update while offline (inspection forms, orders)
  • App State: User preferences or context that should persist (last screen viewed, sync timestamp)

By narrowing the scope to what’s truly needed offline, you keep your data set lean, improving performance and reducing the chance of hitting storage limits.

2. Implementing Initial Data Caching

Cache essential data at app startup (when a connection is available) using the app’s OnStart property:

// In App.OnStart
If(
    Connection.Connected,
    // **Online**: cache critical data
    ClearCollect(EquipmentCache, EquipmentDataSource);
    ClearCollect(WorkOrderCache, Filter(WorkOrdersSource, AssignedTo = User().Email));
    // Save caches to device
    SaveData(EquipmentCache, "EquipmentCache");
    SaveData(WorkOrderCache, "WorkOrderCache");
    // Record the last sync time
    Set(lastSyncTime, Now());
    SaveData(Table({ lastSyncTime: lastSyncTime }), "SyncInfo")
);

This code:

  1. Checks if the device is online
  2. If online, loads equipment data and the user’s assigned work orders into collections
  3. Saves those collections to the device using SaveData
  4. Records when this data was last refreshed

Now, whenever the app launches with a connection, it refreshes the local caches.

3. Loading Data When Offline

Next, we need to load cached data when there’s no internet. Extend the OnStart logic:

// In App.OnStart (extended)
If(
    Connection.Connected,
    // **Online**: retrieve fresh data
    ClearCollect(EquipmentData, EquipmentDataSource);
    ClearCollect(WorkOrders, Filter(WorkOrdersSource, AssignedTo = User().Email));
    ,
    // **Offline**: load data from local cache
    LoadData(EquipmentData, "EquipmentCache", true);
    LoadData(WorkOrders, "WorkOrderCache", true)
);
    
// Set offline mode flag for the app
Set(isOfflineMode, !Connection.Connected);

This approach:

  1. Retrieves data directly from the source if online
  2. Loads the cached data if offline
  3. Sets an isOfflineMode flag to toggle UI elements or show offline indicators

The result is that after this code runs, EquipmentData and WorkOrders will contain data either from the server (if online) or from device cache (if offline). Your app can use these collections without worrying about where the data came from.

4. Tracking Offline Changes

When users make changes while offline, we need to capture them so they can be synchronized later:

// When saving an inspection form offline (OnSelect of "Save" button)
Collect(
    OfflineChanges,
    {
        ID: GUID(),
        EntityType: "Inspection",
        RecordID: ThisItem.ID,        // or a temp ID if new record
        ChangeType: "Update",        // could be "Create", "Update", or "Delete"
        ChangeData: frmInspectionData, // the collected form inputs
        ChangeTime: Now()
    }
);
// Persist the changes locally
SaveData(OfflineChanges, "PendingChanges");

This code:

  1. Adds a record to an OfflineChanges collection, documenting what changed
  2. Includes metadata like the type of change and when it occurred
  3. Immediately saves this collection to device storage

By capturing changes in this structured way, you queue them up for later synchronization without losing anything if the app closes.

5. Implementing Synchronization

The final piece is syncing queued changes back to the server when a connection becomes available:

// OnSelect property of the "Sync" button
If(
    Connection.Connected,
    // **Online**: process each offline change
    ForAll(
        OfflineChanges,
        Switch(
            ThisRecord.ChangeType,
            "Create", Patch(InspectionsDataSource, Defaults(InspectionsDataSource), ThisRecord.ChangeData),
            "Update", Patch(InspectionsDataSource, LookUp(InspectionsDataSource, ID = ThisRecord.RecordID), ThisRecord.ChangeData),
            "Delete", Remove(InspectionsDataSource, LookUp(InspectionsDataSource, ID = ThisRecord.RecordID))
        )
    );
    // After processing, clear the offline changes
    Clear(OfflineChanges);
    SaveData(OfflineChanges, "PendingChanges");
    // Refresh the caches with latest server data
    ClearCollect(EquipmentData, EquipmentDataSource);
    ClearCollect(WorkOrders, Filter(WorkOrdersSource, AssignedTo = User().Email));
    SaveData(EquipmentData, "EquipmentCache");
    SaveData(WorkOrders, "WorkOrderCache");
    // Update sync status and timestamp
    Set(lastSyncTime, Now());
    Set(syncSuccessful, true);
    SaveData(Table({ lastSyncTime: lastSyncTime }), "SyncInfo");
    ,
    // **Offline**: if sync attempted without connection
    Set(syncSuccessful, false)
);

This code:

  1. Processes each offline change based on its type (create, update, or delete)
  2. Clears the offline changes once processed
  3. Refreshes the local caches with the latest server data
  4. Updates the last sync timestamp
  5. Sets a status flag to indicate sync success or failure

This synchronization ensures that once a connection is restored, all offline changes are applied to the backend and local caches are refreshed.

User Experience Best Practices

To create a seamless offline experience, implement these UI elements:

  1. Connection Status Indicator: Show users when they’re working offline with a subtle banner or icon
  2. Last Sync Information: Display when data was last synchronized (e.g., “Last synced: 3/6/2025 10:45 AM”)
  3. Sync Button: Give users a way to manually trigger synchronization when they’re back online
  4. Sync Status Notification: After sync, show a brief confirmation like “All changes synced!” or “Sync failed: You’re offline”

These visual cues build user confidence by making the app’s state transparent. Users need to know if they’re working with the latest data or need to sync changes.

Key Considerations

As you implement offline capabilities, keep these points in mind:

Storage Limits

  • Web Player: Limited to 1 MB for SaveData
  • Mobile Apps: Limited by device storage, but keep it reasonable for performance

Data Prioritization

  • Cache only what users truly need offline
  • For large datasets, implement filtering to cache only relevant subsets

Conflict Handling

In multi-user systems, you may need a strategy for handling conflicts when the same record is modified by different users while offline. Options include:

  • Last writer wins (simplest approach)
  • Timestamp comparison to determine precedence
  • Conflict flagging for manual resolution

Testing

Thoroughly test your offline implementation by:

  • Enabling airplane mode to simulate complete connection loss
  • Testing with slow or intermittent connections
  • Verifying behavior when transitioning between online and offline
  • Confirming changes sync properly when reconnected

Conclusion

Offline capabilities are a game-changer for mobile Canvas Apps. By leveraging SaveData and LoadData to cache data and building a sync mechanism for when connectivity returns, you can create robust, offline-ready solutions that keep users productive no matter where they are.

The journey to offline-capable apps might seem complex at first, but the workflow is straightforward once you understand the pattern:

  1. Cache data when online using SaveData
  2. Load from cache when offline using LoadData
  3. Track changes made while offline
  4. Sync those changes when a connection is restored

Now your field technicians, like ours, can continue their digital workflow even in remote areas. The results? Happier users, fewer headaches, and no more returning to paper forms when connectivity fails.

Remember these key takeaways:

  • Plan what data is truly needed offline
  • Cache on launch when connectivity is available
  • Use local collections for offline changes
  • Provide clear visual indicators of online/offline status
  • Test thoroughly in various connectivity scenarios

What offline scenarios do you need to support in your Power Apps? With SaveData and LoadData, you have the tools to ensure your apps work flawlessly, online or off.