Skip to main content

Reactive System

Automatic updates throughout your pipeline—change one thing, and everything downstream recalculates.

What is the Reactive System?​

Shadowfax's reactive system ensures your analysis stays consistent. When you update a Source, edit a View, or change an Input Object, every downstream transformation automatically recalculates. No broken formulas. No manual refreshes. No stale data.

It's like spreadsheet formulas that work across your entire analytical pipeline.

Reactive Flow

Change propagates automatically through dependent Views

Why the Reactive System Matters​

Always current: Your analysis updates when source data changes.

No broken dependencies: Fix an early transformation, and everything downstream corrects automatically.

Confident iteration: Experiment freely knowing all results will stay consistent.

Time savings: No manual refresh clicking or formula copying.

Error prevention: Eliminates the risk of analyzing outdated Views.

How It Works​

Dependency Tracking​

Shadowfax tracks every relationship:

  • Which Views depend on which Sources
  • Which Views depend on other Views
  • Which visualizations depend on which Views
  • Which Input Objects feed which Views

This creates a dependency graph that determines what needs updating.

Dependency Graph

Visual representation of dependencies

Automatic Propagation​

When you change anything:

  1. Detect change: System identifies what changed
  2. Find dependents: Locate all downstream Views
  3. Recalculate: Update each dependent in order
  4. Cascade: Continue until all affected Views update
  5. Refresh visuals: Update charts and dashboards

All happens in seconds, automatically.

Common Scenarios​

Updating Source Data​

Scenario: Upload a new version of your sales CSV

What happens:

  • All Views using that Source recalculate
  • Any Views depending on those Views also update
  • Visualizations refresh
  • Your dashboard shows current numbers

You do: Nothing. Just upload and wait a few seconds.

Source Update

New source data triggers downstream updates

Fixing a Transformation​

Scenario: You notice a filter in an early View is wrong

What happens:

  • You edit that View
  • All Views downstream recalculate with the corrected data
  • Final results automatically reflect the fix
  • Visualizations update

You do: Fix the one View. System handles the rest.

Changing Input Objects​

Scenario: Adjust discount rate from 15% to 20%

What happens:

  • Every View using that discount rate recalculates
  • Revenue projections update
  • Comparison charts refresh
  • KPI cards show new numbers

You do: Edit the Input Object value. Everything else is automatic.

Input Change Propagation

Changing one variable updates entire analysis

Modifying View Logic​

Scenario: Change how you calculate customer lifetime value

What happens:

  • The edited View recalculates
  • Any Views that segment or aggregate CLV update
  • Comparison Views recalculate
  • Charts based on CLV refresh

You do: Update the single View. Dependencies resolve automatically.

Understanding Update Order​

Topological Sorting​

The system calculates Views in dependency order:

  1. Sources and Inputs (no dependencies)
  2. First-level Views (depend only on Sources/Inputs)
  3. Second-level Views (depend on first-level Views)
  4. And so on...

This ensures no View calculates before its dependencies are ready.

Update Order

Views update in correct dependency order

Parallel Execution​

When possible, independent Views update in parallel for speed:

  • Views depending on Source A
  • Views depending on Source B
  • Both can update simultaneously

Benefits for Iterative Analysis​

Experiment Freely​

Try different approaches without fear:

  • Test a new join condition
  • Adjust filter criteria
  • Try different aggregation methods
  • Modify calculations

If something doesn't work, just revert. All dependent Views will adjust.

Incremental Refinement​

Build analysis step-by-step:

  1. Create basic Views
  2. Check results
  3. Refine early Views
  4. Watch downstream results improve automatically

No need to rebuild from scratch each time.

Multi-Path Analysis​

Create multiple analytical paths from the same Source:

  • Path 1: Focus on revenue
  • Path 2: Focus on customer behavior
  • Path 3: Focus on product performance

Update the Source once, all three paths update.

Multi-Path Updates

One source update refreshes multiple analysis paths

Performance Considerations​

Smart Caching​

Shadowfax only recalculates what changed:

  • Edit one View → only that View and its dependents update
  • Unrelated Views stay cached
  • Large Workbooks remain fast

Update Indicators​

While Views update:

  • Loading indicators appear
  • Status shows "Calculating..."
  • You can continue working

Most updates complete in seconds.

Tips & Best Practices​

Let it work: Don't manually refresh or duplicate Views—trust the reactive system.

Fix upstream: When results look wrong, check earlier Views first. Fixing the source of the problem updates everything downstream.

Check dependencies before deleting: The system warns if other Views depend on what you're deleting.

Use the graph to understand flow: See the node graph to visualize what will update when you make changes.

Edit Input Objects for quick scenarios: Faster than editing Views because the transformation logic stays the same.

Be patient with large pipelines: Complex Workbooks with many Views may take 10-20 seconds to fully update.

What Doesn't Auto-Update​

AI Tables: These require manual refresh to control token usage. The system won't automatically reprocess AI Tables when upstream data changes.

Archived Workbooks: Inactive Workbooks don't run updates until you reopen them.

Troubleshooting​

Updates taking too long?

  • Check the size of your upstream Views
  • Simplify complex Views if possible
  • Consider filtering earlier in the pipeline

View not updating?

  • Check that there's actually a dependency connection
  • Verify the upstream View completed successfully
  • Look for errors in intermediate Views

Unexpected changes?

  • Trace dependencies in the node graph
  • Check if an Input Object changed
  • Verify Source data hasn't been replaced