TraceForge: Building a Graph-Powered Incident Investigation Command Center with FalkorDB
Discover how TraceForge uses FalkorDB and graph-powered investigation to trace service dependencies, analyze incident blast radius, compare hypotheses, and simulate interventions. Built for WeMakeDevs × FalkorDB Graph Hacks 2026.
TraceForge: Building a Graph-Powered Incident Investigation Command Center with FalkorDB
The problem: An incident is rarely isolated
Imagine a payment service begins experiencing high latency. Requests start timing out. The checkout service reports upstream failures, database connections approach their configured limit, and the incident begins affecting downstream systems.
An engineer looking at individual alerts sees symptoms. What they really need is context.
Which services depend on the failing component? Which alerts are related? What evidence supports a possible root cause? How far could the failure propagate? And what might happen if a dependency is changed?
These questions motivated TraceForge, a graph-powered incident investigation and operational decision-support platform built for WeMakeDevs × FalkorDB Graph Hacks 2026.
The central idea is simple: operational relationships should be queryable data, not just lines drawn on a dashboard.
Introducing TraceForge
TraceForge brings incident investigation, service dependency analysis, evidence exploration, hypothesis comparison, and graph-intervention simulation into one command center.
The application is designed around an incident-response workflow:
- Inspect the active incident and correlated alerts.
- Explore the affected service topology.
- Trace dependencies and investigate potential blast radius.
- Examine evidence and compare possible explanations.
- Evaluate a proposed graph intervention before treating it as a real operational change.
The objective is not to replace an engineer's judgment. It is to make the relationships and evidence relevant to that judgment easier to investigate.
Why FalkorDB?
A service topology is naturally relational. A service depends on another service; an incident affects a component; an alert is associated with a service; a deployment may overlap with the incident timeline.
A flat list can store these entities, but understanding multi-hop relationships requires repeatedly following connections.
That is where a graph database becomes useful.
TraceForge uses FalkorDB as its graph database, with a Python/FastAPI backend connecting graph operations to the application's investigation workflow.
The important architectural decision is that the graph is intended to support investigation itself. Dependency paths and connected components can help answer operational questions that a simple screenshot of a topology cannot answer.
For example:
- What components are connected to the service under investigation?
- Which dependency paths could explain an observed failure?
- What is the potential scope of a proposed topology change?
The value comes from querying and interpreting relationships, not from the visual appearance of the graph alone.
Inside the architecture
TraceForge uses the following technology stack:
- Frontend: React, TypeScript, and Vite
- Backend: Python and FastAPI
- Graph database: FalkorDB Cloud
- Agent/tool integration: MCP
- Deployment: Vercel for the frontend and Render for the backend
The frontend presents the incident workflow. The backend handles application requests and graph-related operations. FalkorDB stores connected operational data and supports graph queries. MCP provides a tool interface for relevant investigation operations.

A useful architecture diagram should show the direction of requests and results, the graph database boundary, and where MCP tools are invoked. It should reflect the implementation rather than suggesting components that are not present.
A walkthrough: Investigating a payment incident
Consider the incident displayed in the TraceForge command center:
Incident: INC-2026-8821
Scenario: Payment Core Connection Starvation and High Error Rate
The dashboard shows correlated alerts for gateway timeouts, elevated payment-core latency, exhausted database connections, and checkout upstream timeouts.
It also shows a ranked root-cause candidate and impacted services.
These dashboard values are scenario data, not independent proof of a real production outage. Their purpose is to provide a concrete incident-investigation workflow that can be explored in the application.
Step 1: Establish the incident context
The command center brings the incident summary, alerts, candidate deployments, affected services, and associated runbook into one view.
This creates a starting point for investigation instead of forcing the engineer to treat each alert as an unrelated event.

Step 2: Follow the dependencies
The next question is how the affected services relate to one another.
A graph representation makes those relationships explicit. Rather than merely viewing individual service statuses, an engineer can explore connected services and the paths between them.
Multi-hop traversal is particularly useful when an incident in one component may affect components further downstream.


The exact result depends on the graph model, its loaded data, and the query being executed. For that reason, a technical demonstration should show the actual graph operation or explain the query that produced the displayed result.
Step 3: Examine evidence and competing hypotheses
An incident often has several plausible explanations. A deployment, a saturated connection pool, and an upstream dependency failure can produce overlapping symptoms.
TraceForge includes evidence and hypothesis investigation workflows intended to help organize these possibilities.
The distinction between evidence and inference matters. A ranked hypothesis is a candidate explanation, not necessarily a confirmed root cause. The strength of a conclusion depends on the data and the logic used to produce it.


Step 4: Evaluate an intervention
TraceForge also includes a graph-intervention workflow called Graph Surgery.
This provides a way to explore a proposed change to the topology and inspect its potential consequences before treating that change as an operational action.
A simulation is not the same as safely executing a change in a live production environment. It is important to make that distinction explicit in both the interface and the documentation.

Making the graph do meaningful work
One of the most important requirements of Graph Hacks is that FalkorDB must be central to the product rather than used only to draw a visualization.
For TraceForge, this means documenting the actual graph schema, representative Cypher queries, and the relationship between graph operations and the results presented to the user.
The repository should explain:
- Which entities are represented as graph nodes.
- Which relationships connect those entities.
- How dependency traversal is performed.
- How the application computes or retrieves blast-radius information.
- How intervention simulations modify or evaluate graph state.
- Which outputs are observations, inferred results, or simulated outcomes.

These details are important because they make the design reviewable and reproducible. They also help distinguish a graph-backed investigation system from a conventional dashboard with a graph-shaped interface.
Engineering and deployment
The application separates the browser interface from the API backend and hosted graph database.
The frontend is deployed on Vercel, while the backend is deployed on Render and connects to FalkorDB Cloud.
The repository should contain local setup instructions, an environment-variable template, test commands, and the actual graph model and query logic. Credentials should remain in environment variables and must never be committed to the public repository.
Testing should cover both the basic API behavior and the graph-dependent functionality. A successful health check is useful, but it does not by itself prove that the graph queries, seeded data, or investigation workflow are working correctly.
What we learned
Building TraceForge reinforced several useful engineering lessons.
First, the graph must be part of the reasoning workflow. A topology visualization is valuable, but the deeper benefit comes from using relationships to answer questions about dependencies and impact.
Second, evidence and inference should remain distinguishable. An alert is an observation. A suspected root cause is a hypothesis. A simulated intervention is an estimate of a possible outcome. Conflating them can create false confidence.
Third, simulation needs clear boundaries. Evaluating a proposed graph change is different from executing a change against production infrastructure. The interface should communicate which of these has occurred.
Finally, a deployed application is only one part of a credible technical project. The graph model, queries, tests, setup instructions, and explanation of technical decisions are necessary to understand and reproduce the work.
Current scope and future work
TraceForge is a hackathon project focused on graph-grounded incident investigation and intervention simulation.
Potential future work includes validating graph-derived conclusions against richer telemetry, improving query observability, expanding automated tests for multi-hop dependency cases, and integrating controlled workflows for approved recovery actions.
Any future autonomous action capability would need explicit authorization, auditability, and safeguards. A simulated intervention should never be presented as a real production change.
Try TraceForge
Explore the deployed application:
The source repository contains the implementation, graph model, setup instructions, and relevant queries:
TraceForge was built for WeMakeDevs × FalkorDB Graph Hacks 2026, with a focus on the Agents That Act on Connected Data track.
The broader lesson is that incident response becomes more useful when engineers can investigate not just individual alerts, but the connected system those alerts describe.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article