Design scalable pagination strategy for large graph data (call graph lazy loading)

[yaredtsy]

Description:

As the system grows, handling large graph datasets efficiently is becoming a critical concern. Current approaches do not scale well when dealing with deeply connected or high-volume graph structures.

This issue focuses on defining a robust pagination strategy that works naturally with our graph-based architecture.

Problem

• Graph data (especially call graphs) can grow very large and deeply nested.
• Loading entire graphs at once is inefficient and impacts performance.
• Traditional pagination (page/offset) does not map well to graph traversal.

Proposed Direction

• Explore lazy loading for call graphs as a primary approach.

• Load nodes and edges incrementally based on user interaction or focus.

• Treat call graphs as naturally isolatable units, making them easier to:

  • Track
  • Render
  • Navigate

Goals

• Reduce initial load time for large graphs
• Improve UI responsiveness and developer experience
• Enable working on isolated parts of the graph without loading everything
• Maintain consistency with the graph-based mental model

Open Questions

• What is the best traversal strategy for incremental loading? (BFS, DFS, depth-limited?)
• How should we cache previously loaded subgraphs?
• How do we handle pagination across relationships (edges) vs nodes?
• Should pagination be user-driven (expand node) or automatic (viewport-based)?
• How do we manage state across sessions?

Notes

• Call graph lazy loading seems like the most promising short-term solution.
• This should align with the broader goal of making large codebases easier to explore and isolate.