0%
ArcGIS Experience Builder Training

10 Advanced
Tips & Tricks

Power-user patterns that separate functional apps from great ones. URL deep links, data pipelines, Arcade styling, performance, and the new AI Assistant.

Beginner — 3 tips Intermediate — 3 tips Advanced — 4 tips

What's inside

Quick Wins

Three tips you can apply in under five minutes. No code, no complex configuration — just toggles and settings that immediately improve your apps.

Tip 1

Use the Share Widget to Reverse-Engineer URL Parameters

Experience Builder URL parameters are notoriously complex. They require knowledge of internal data source IDs, widget IDs, proper URL encoding, and JSON-like syntax. A typical parameterized URL looks like this:

Typical EB parameterized URL
https://experience.arcgis.com/experience/abc123
  ?data_filter=dataSource_1-layer_0:status%3D%27Active%27
  #map_1=center:-9175753,3251009,102100&map_1=scale:500000

Nobody wants to hand-write that. Get one character wrong and the whole thing fails silently — the app loads but the parameter is ignored.

The solution: Let the app write the parameters for you. The Share widget captures your current app state as a URL.

1
Add a Share widget to any page — placement doesn't matter since this is a dev tool
2
Configure it: toggle ON "Include URL Parameters"
3
Preview the app. Set the exact state you want to capture: zoom the map, apply filters, turn layers on/off, select a feature, navigate to a specific page
4
Click the Share widget in the preview. Copy the generated URL
5
Deconstruct the URL to understand the syntax. Reuse parts of it in emails, external links, or other applications
Try it

Open any EB app in the builder, drop in a Share widget, preview it, zoom to a specific area, turn off a layer, and click Share. Look at the URL it produces. You'll see exact parameter syntax for center, scale, layer visibility, and filters — all properly encoded.

Key concept

Remove the Share widget before publishing if you don't want end users to see it — it's purely a development tool. Save the generated URLs in a reference doc so you don't have to regenerate them.

Tip 2

Section Widget Lazy Loading for Performance

You build an EB app with a tabbed Section widget: View 1 is a Map, View 2 is a Chart dashboard, View 3 is a Table, View 4 is a gallery. On page load, EB renders all views simultaneously — even though the user only sees View 1. Everything initializes at once, and the page takes 10-15 seconds to load.

One toggle fixes this: Select your Section widget → Settings → find "Lazy Loading" → turn it ON.

BehaviorWithout Lazy LoadingWith Lazy Loading
Page loadAll views render at onceOnly the visible view renders
Tab switch (first visit)Instant (already loaded)1-3 second delay
Tab switch (return)InstantInstant (stays loaded)
Memory usageHigh (all views in DOM)Lower (only visited views)
Think of it this way

Without lazy loading, opening a restaurant means firing up every oven, grill, and deep fryer at 6 AM — even though the first order won't come in until noon. Lazy loading means you turn on equipment when the first order for that station comes in.

When to use vs. when not to

Use it when: 3+ views, views contain Maps/Charts/Tables, users typically visit only 1-2 views, mobile performance matters.

Don't use it when: Only 2 simple views, all views will be visited every session, the brief loading delay would be disruptive (e.g., a real-time monitoring dashboard).

Stack with these
  • Set record limits on List/Table widgets (don't load 10,000 records)
  • Use pagination on Tables (25-50 records per page)
  • Enable scale-dependent rendering on layers
  • Use hosted tile layers for basemaps (pre-rendered, no server processing)
Tip 3

Pending Mode — Responsive Design Without Deleting Widgets

You build a desktop app with a sidebar, legend, filter bar, and full-screen map. Switch to mobile preview: everything overlaps or squishes. The instinct: delete the sidebar. But in EB, deleting from one layout deletes from ALL layouts. Now your desktop is broken too.

The Pending List is a holding area. Widgets moved there are fully configured, invisible to users on that device layout, and still exist on other layouts.

1
Switch to mobile view using the device icons at the top of the builder
2
Identify widgets that don't fit: sidebars, legends, secondary panels
3
Select a widget, click "Move to Pending" (or drag to the Pending List area at the bottom of the widget tree)
4
Repeat for all non-essential mobile widgets
5
Switch back to desktop — all widgets still there
Widget TypeMobile Strategy
Side panels / SidebarsHide → replace with bottom sheet or overlay
LegendsHide → use Map's built-in layer list toggle
Filter bars (horizontal)Hide → replace with compact filter button
The MapKEEP → make it 100% width
Primary ListKEEP → make it full-width
Search barKEEP → essential for mobile navigation
Critical

Always switch to Custom layout mode for responsive work. Auto mode makes educated guesses, but they're frequently wrong — it might stack a sidebar below the map instead of hiding it.

Quick check: You want to hide a legend on mobile but keep it on desktop. What do you do?

Configuration Patterns

These tips require understanding specific syntax or configuration details, but no code. Master these and you'll unlock capabilities most EB users never discover.

Tip 4

Shared Authentication Between Embedded Apps

You embed a Dashboard inside your EB app. Both are secured. The user signs into the parent EB app, then gets a second sign-in prompt for the embedded Dashboard. Confusing, frustrating, unprofessional.

Fix: Append ?arcgis-auth-origin=https://experience.arcgis.com to the embedded app's URL.

1
Note your parent EB app's URL: https://experience.arcgis.com/experience/abc123
2
Add an Embed widget to your EB app
3
Set the source URL with the auth parameter appended
4
Save and preview — the embedded app authenticates automatically
Embed URL with shared auth
https://yourorg.maps.arcgis.com/apps/dashboards/def456
  ?arcgis-auth-origin=https://experience.arcgis.com
  &arcgis-auth-portal=https://yourorg.maps.arcgis.com
  &org=yourorgshortname
App TypeShared Auth Works?
ArcGIS DashboardYes — most common use case
Another EB appYes — nested EB apps work well
Web AppBuilder appYes
ArcGIS StoryMapYes
Custom web app (non-ArcGIS)No — must implement ArcGIS Identity manually
Additional parameters
  • ?org=yourorgshortname — skips the generic login page, goes directly to your org's branded sign-in (important for SAML/SSO/2FA orgs)
  • ?arcgis-auth-portal=https://yourorg.maps.arcgis.com — forces auth against a specific portal (useful for orgs with both AGOL and Enterprise)
Tip 5

Arcade AI Assistant + HTML Output

As of the February 2026 ArcGIS Online update, the Arcade expression editor includes an AI-powered assistant (beta). Describe what you want in plain English and it generates the Arcade expression.

1
Open any widget that supports Arcade (Text, List, Button, Image, Chart)
2
Click the Arcade editor — the purple {} icon
3
Find the Arcade Assistant chat input area
4
Type a natural language instruction, e.g.: "Show the feature name in bold. If status is Critical, make it red."
5
Review and edit the generated code — fix field names to match your actual schema
TaskAI Quality
Conditional formatting (IIf, When, Decode)Excellent
Date math (DateDiff, DateAdd, formatting)Excellent
String concatenation and formattingGood
Basic HTML output generationGood
FeatureSet queries (cross-layer lookups)Fair
Complex spatial calculationsPoor — write these manually

Arcade can return formatted HTML using supported tags: <h1>-<h6>, <p>, <span>, <strong>, <em>, <a>, <img>, <ul>/<ol>/<li>, <br>. Not supported: <div>, <table>, <style>, <script>.

Arcade — chapter status card with HTML output
var name = $feature.ChapterName
var activeOps = $feature.ActiveOperations
var daysAgo = Floor(DateDiff(Now(), $feature.EditDate, "days"))

var statusColor = When(
  activeOps > 5, "red",
  activeOps > 0, "orange",
  "green"
)

return "<h3>" + name + "</h3>" +
       "<p style='color:" + statusColor + "; font-weight:bold'>" +
       activeOps + " operations</p>" +
       "<p style='color:#666; font-size:12px'>Updated " +
       daysAgo + " days ago</p>"
The 10-expression limit

Each page supports a maximum of 10 Arcade expressions (dynamic styling + content + data expressions + Arcade filters combined). Budget carefully. If you need more: move widgets to a different page, use Section views (separate expression budget), or pre-calculate values in your Feature Layer.

Tip 6

Deep Link with Hash Parameters

While Tip 1 auto-generates URLs, this tip teaches you the actual syntax so you can construct deep links programmatically — from external systems, email templates, or code.

TypeSyntaxPurpose
Query parameters?key=valueData filters, page navigation, extent, auth
Hash parameters#key=valueMap state: center, zoom, layers, markers

Center and scale:

Center the map on a specific location
// Web Mercator coordinates + scale
#map_1=center:-9175753,3251009,102100&map_1=scale:500000

// Lat/lon alternative
#map_1=center:-82.64,27.77,4326&map_1=scale:500000

Layer visibility:

Toggle layers on/off via URL
#map_1=layer_visibility:{"dataSource_1":{"layer-2":false,"layer-3":true}}

Drop markers:

Place a temporary marker
#map_1=marker:-82.64,27.77;4326;St Petersburg;Click here for details

Pre-filter data:

Filter features before the app renders
?data_filter=dataSource_1-layer_0:status='Active' AND region='Southeast'

Combined URL — the real power:

Full deep link example
https://experience.arcgis.com/experience/abc123
  ?data_filter=dataSource_1-layer_0:region='Southeast'
  &page=page_2
  #map_1=center:-9175753,3251009,102100
  &map_1=scale:500000
  &map_1=layer_visibility:%7B%22dataSource_1%22%3A%7B%22layer-2%22%3Afalse%7D%7D
ScaleApproximate View
150,000,000World
20,000,000Country
5,000,000Multi-state region
500,000Metro area
50,000City
10,000Neighborhood
Try it

Create a set of links for stakeholders — each link opens the same app pre-filtered and pre-zoomed to their region. Email them the links. One app, personalized views.

Quick check: What's the difference between query parameters (?key=value) and hash parameters (#key=value)?

Architecture Patterns

These four tips change how you think about building EB apps. They're architectural patterns — data pipelines, independent views, dynamic styling, and cross-page workflows — that power production-grade applications.

Tip 7

Chain Widget Output Data Sources into Pipelines

This is the most powerful architectural pattern in EB that most users never discover. Certain widgets don't just display data — they produce new data sources at runtime. These output data sources can be consumed by other widgets, creating processing pipelines entirely through configuration.

Think of it this way

Unix pipes: cat file | grep "error" | wc -l — each command takes input from the previous one. In EB, each widget takes data from the previous widget's output.

WidgetWhat It ProducesOutput Contains
QueryFiltered record setRecords matching criteria
ChartStatisticsSum, average, count, min, max
Near MeProximity resultsFeatures within distance + summary
SearchGeocoded locationsAddress match results
FilterFiltered subsetFeatures passing criteria

Pattern 1: Basic Pipeline (Query → List + Chart)

Feature Layer
All incidents
Query Widget
status = 'Active'
List + Chart
Show active only

Pattern 2: Two-Level Pipeline (Query → Chart → Text)

Query
Filter: Active
Chart
Response times
Text
"Avg: 4.2 hours"
Pipeline architecture rules
  • Output data sources are independent — filtering on an output doesn't affect the original source
  • Pipelines can cross pages if both pages reference the same underlying data source
  • Don't chain more than 2 levels deep — Query → Chart → Text is fine; deeper gets hard to debug
  • Output data sources update in real-time when the source changes or the user interacts upstream
Why this matters

Without pipelines, if your filter logic changes, you update it in 3+ separate places (one per widget). With pipelines, you update it in one place — the Query widget — and all downstream widgets reflect the change automatically.

Tip 8

Custom Data Views for Independent Widget Slices

You have a Map and a List both connected to the same Feature Layer. You add a filter to the List for "Active" incidents. The Map also filters to Active — your historical incidents vanish from the map. Everything connected to the same data source shares the same filter state.

This is the #1 frustration for intermediate EB builders.

The solution: Named Data Views. A Data View is a configured lens on a data source with its own filter, sort, and record limit. Multiple widgets each use a different view, operating independently.

1
Open the Data panel (left sidebar)
2
Find your Feature Layer, click the + icon next to it
3
Name the view descriptively: "Active Incidents", "Map View - All", "Critical Only"
4
Configure: set Filter, Sort, and Record limit
5
Assign the view to a widget in its data settings
Action TargetWhat Happens
Filter on the Default ViewALL widgets using that data source are affected
Filter on a Named ViewONLY widgets using that specific view are affected
The critical rule

Use the Default View for global interactions (user clicks map → everything updates). Use Named Views for isolated interactions (filter panel → only the list updates). This is the single most important thing to understand about EB data architecture.

Combine with pipelines (Tip 7)
  • Pipelines: Use when data should flow through processing stages (Query → Chart → Text)
  • Data Views: Use when different widgets need independent slices of the same data
  • Combined: Map uses Default View (unfiltered), Query-List-Chart pipeline uses "Active Only" view, Detail Panel uses "Selected" view — all independent
Tip 9

Arcade Dynamic Styling — Data-Driven Widget Appearance

Map symbology changes how features look on the map. Dynamic styling changes how widgets look in the UI. A List item can turn red when overdue. A Text block can change colors based on severity. This is conditional formatting for Experience Builder.

WidgetWhat You Can StyleProfile Variable
List (per item)Background, border, text of each row$feature
TextBackground, border, font$dataSource
ButtonBackground, border, text color$dataSource
CardBackground, border$feature
1
Select your widget (e.g., a List)
2
Go to the Style tab
3
Look for the Arcade editor icon — a purple {} next to Background or Border
4
Write an expression that returns a style object
Arcade — color-code list items by status
var status = $feature.Status

var bgColor = When(
  status == "Critical",   "rgba(255, 59, 48, 0.15)",
  status == "Active",     "rgba(255, 149, 0, 0.15)",
  status == "Monitoring", "rgba(255, 204, 0, 0.10)",
  status == "Resolved",   "rgba(52, 199, 89, 0.10)",
  "rgba(200, 200, 200, 0.05)"
)

var borderColor = When(
  status == "Critical",   "#FF3B30",
  status == "Active",     "#FF9500",
  status == "Monitoring", "#FFCC00",
  status == "Resolved",   "#34C759",
  "#CCCCCC"
)

return {
  background: { color: bgColor },
  border: { type: "solid", color: borderColor, width: "2px" }
}
Arcade — highlight overdue items
var daysOverdue = DateDiff(Now(), $feature.DueDate, "days")

if (daysOverdue > 0) {
  return {
    background: { color: "rgba(255, 59, 48, 0.2)" },
    border: { type: "solid", color: "#FF3B30", width: "3px" }
  }
} else if (daysOverdue > -3) {
  return {
    background: { color: "rgba(255, 204, 0, 0.15)" },
    border: { type: "solid", color: "#FFCC00", width: "2px" }
  }
} else {
  return {
    background: { color: "rgba(52, 199, 89, 0.05)" },
    border: { type: "solid", color: "#34C759", width: "1px" }
  }
}
Remember the 10-expression limit

Dynamic styling expressions count toward the per-page limit of 10 Arcade expressions. Budget them alongside dynamic content, data expressions, and Arcade filters.

Tip 10

Cross-Page Trigger-Action Chains

Most EB users know about triggers within a single page. But the system is far more powerful:

Multi-action

Multiple actions fire from a single trigger, executing sequentially

Cross-page

Actions can target widgets on other pages

Chains

Complex interactive workflows without any code

Multi-Action Chain: User clicks a feature → map pans and zooms → sidebar opens → list filters → feature flashes.

1
Select the Map widget, go to the Action tab
2
Add trigger: "Record selection changes"
3
Add Action 1: Pan to → this Map widget
4
Add Action 2: Zoom to → scale 50,000
5
Add Action 3: Open → Sidebar widget
6
Add Action 4: Filter → List widget (filter by region)
7
Add Action 5: Flash → 3 seconds

Cross-Page Pattern: Overview page → user clicks a region → app navigates to detail page pre-filtered.

Page 1: Map
Click region
Filter Page 2
by region field
Navigate
to Page 2
Gotchas
  • 1,000 feature limit: Selections with 1,000+ features may cause cross-page actions to fail. Pre-filter to keep selection sets small
  • Action order matters: Put the Filter action BEFORE the Navigate action. Otherwise navigation happens before the filter applies
  • Same data source required: Both pages must use the same underlying data source for cross-page actions to work
  • Mobile performance: Keep chains to 2-3 actions on mobile layouts — visual effects (Flash, Pan, Zoom) can lag

Quick check: You want a Map click on Page 1 to filter a List on Page 2 and then navigate there. What order do you configure the actions?

Quick Reference

Tips at a Glance

TipWhatComplexity
1. Share Widget URLsAuto-generate URL parametersLow
2. Lazy LoadingDefer rendering of hidden Section viewsLow
3. Pending ModeHide widgets per device without deletingLow
4. Shared AuthSingle sign-on for embedded appsLow
5. AI AssistantNatural language → Arcade + HTML outputLow-Med
6. Hash ParametersManual deep linking syntaxMedium
7. Data PipelinesWidget-to-widget output chainingMedium
8. Data ViewsIndependent widget filteringMedium
9. Arcade StylingData-driven widget colors/bordersMed-High
10. Cross-Page TriggersMulti-page interactive workflowsMedium
Combination patterns
  • Full-Featured Ops Dashboard: Data Views (8) + Pipelines (7) + Dynamic Styling (9) + Cross-Page Triggers (10) + Lazy Loading (2)
  • Stakeholder Briefing App: Deep Links (6) + Share Widget (1) + Pending Mode (3) + Shared Auth (4)
  • Data-Rich Analysis App: Pipelines (7) + Data Views (8) + Dynamic Styling (9) + AI Assistant (5)