Mobile case load times are slow in Pega 8.5 mobile apps for field agents

BPM Pega Platform
, , , , , , , ,
1

We’re experiencing significant performance issues with our Pega 8.5 mobile deployment for field agents. Case load times are averaging 8-12 seconds, which is impacting productivity during customer visits.

Our field agents work with insurance claims cases that include photos, PDF documents, and customer data. The slow loading is particularly noticeable when:

  • Opening cases from the work queue (8-10 seconds)
  • Switching between cases (6-8 seconds)
  • Loading case attachments (10+ seconds)

We have offline caching enabled, but it doesn’t seem to be helping much. Our data pages are set to load on access, and we’re using the default sync configuration. The mobile app works fine on WiFi, but performance degrades significantly on cellular networks.

Are there specific configuration changes we should make to improve mobile case load times? We need our agents to be able to access cases quickly while in the field.

2

Your attachment loading strategy is definitely part of the problem. Loading 1.5-10MB of attachment data with every case is killing your mobile performance, especially on cellular.

For the data pages, switching to Thread scope for reference data will help, but you also need to implement lazy loading for attachments. Set up separate data pages for attachments that only load when the user explicitly opens them. This alone could cut your load times by 60-70%.

Also consider implementing incremental sync - instead of syncing entire cases, only sync the delta changes. Pega Mobile Client supports this through the SyncManager API.

3

You can keep the thumbnails - just generate them server-side at a much smaller resolution (maybe 150x150px) and include those in the initial case load. The full attachments stay as separate lazy-loaded data pages.

For the case structure modifications, it’s not too extensive. You’ll need to create separate data pages for attachments and update your sections to call them on-demand. The Mobile SDK provides good examples of this pattern in the MobileOptimization component.

4

I’d add that your offline caching configuration needs attention too. The default sync settings in Pega 8.5 aren’t optimized for field operations with large data sets.

Look at configuring selective sync - only cache the cases assigned to each agent rather than the entire work queue. You can set this up in the Mobile Channel configuration under Offline Support. Also enable background sync so data refreshes happen when the app isn’t actively being used.

What’s your current cache size limit set to?

5

The 8-12 second load times suggest your data pages aren’t optimized for mobile access patterns. Are you using declarative data pages that load all case data at once? That’s a common bottleneck.

Check your data page scope settings - they should be set to Thread scope for frequently accessed reference data rather than Requestor scope. Also verify if you’re loading attachments eagerly instead of on-demand.

6

Thanks for the quick response. Yes, we’re using declarative data pages with Requestor scope for most case data. The attachments are loaded as part of the case structure, so they’re coming down with every case load.

Should we be restructuring how we’re loading this data? We have about 15-20 data pages per case on average, and each case typically has 3-5 attachments ranging from 500KB to 2MB each.

7

Let me provide a comprehensive solution that addresses all three key areas: offline caching, data page optimization, and incremental sync.

Offline Caching Configuration: Navigate to Configure > Channels & Interfaces > Mobile > [Your Channel]. Under Offline Support settings:

  • Enable Selective Sync and set filter criteria to only sync cases where .pxAssignedOperatorID = CurrentOperator
  • Set Cache Size Limit to 250MB (adjust based on your average data volume per agent)
  • Configure Background Sync Interval to 30 minutes when app is idle
  • Enable Smart Sync to prioritize recently modified cases

Data Page Optimization: Restructure your data architecture for mobile performance:

  1. Reference Data: Convert frequently accessed lookup data pages (customer lists, product catalogs, status codes) from Requestor scope to Thread scope. This prevents redundant loading.

  2. Case Data: Split your case data pages into core and extended sets:

    • Core data page: Basic case info, status, assigned operator (loads immediately)
    • Extended data pages: Detailed history, audit trail, related cases (load on-demand)

  3. Attachments: Create separate data pages for attachments:

    • D_AttachmentThumbnails: Small thumbnail images (max 20KB each) loaded with case
    • D_AttachmentFull: Full-size attachments loaded only when user clicks to view
    • Set these to Node scope with 1-hour cache duration

  4. Implement data page parameters to enable lazy loading:

    • Pass CaseID as parameter to attachment data pages
    • Use when rules to control loading based on user actions

Incremental Sync Setup: Implement delta synchronization to minimize data transfer:

  1. In your Mobile Channel configuration, enable Delta Sync under Advanced Settings
  2. Configure the sync timestamp tracking by adding pxUpdateDateTime to your sync filter criteria
  3. Set up conflict resolution rules for offline edits (typically Last Write Wins for field operations)
  4. Implement a sync status indicator in your mobile UI so agents know when data is current

Additional Performance Optimizations:

  • Enable data page preloading for the top 5 most accessed cases in work queue
  • Implement pagination for case lists (20 cases per page maximum)
  • Use lightweight JSON format instead of XML for mobile API calls
  • Configure connection timeout settings: Read timeout 30s, Connection timeout 15s
  • Enable HTTP/2 protocol support in your Pega environment for multiplexed requests

Testing & Validation: After implementing these changes, test on actual cellular network conditions:

  • Use Chrome DevTools Network throttling to simulate 3G/4G speeds
  • Target load times: <2 seconds for case open, <1 second for case switching
  • Monitor sync performance with Pega Mobile diagnostics logging enabled

Expected Results: With these optimizations, you should see:

  • Case load times reduced from 8-12s to 2-3s
  • Attachment loading separated from initial case load
  • Offline cache size reduced by 40-50% through selective sync
  • Background sync keeping data current without impacting active use
  • Better performance on cellular networks through reduced data transfer

Implement these changes in your development environment first and test thoroughly with actual field agents before deploying to production. The combination of optimized caching, lazy loading, and incremental sync will dramatically improve your mobile performance.

8

We haven’t set a specific cache size limit - it’s using the default. I’m looking at the Mobile Channel configuration now and see options for selective sync and background refresh intervals.

For the lazy loading approach, would we need to modify our case type structure significantly? We have custom sections that display attachment thumbnails on the case summary screen.