Skip to main content
The Dependency Mapping Tool is a desktop application that enables IT teams to visualize and manage interconnections across enterprise architecture components—from Active Directory and hypervisors to applications, databases, and cloud services.

​
Why Map Dependencies?

Enterprise environments contain complex webs of interconnected systems. A single change to a domain controller, hypervisor, or core service can cascade through dozens of dependent systems. Without clear visibility into these relationships, teams face:
  • Unplanned outages from changes to upstream dependencies
  • Security blind spots where compromise paths aren’t understood
  • Lengthy incident response while tracing impact across systems
  • Failed migrations due to undocumented dependencies
This tool provides a single source of truth for how your infrastructure components relate to each other.

​
Key Features

Interactive Visualization

Graph-based representation using Cytoscape.js with click-to-explore functionality, adjustable depth control (1-3 levels), and multiple layout algorithms.

Environment Management

Isolated configurations for dev, staging, production, or custom environments with seamless switching and per-environment data isolation.

Component Configuration

Support for nine component types spanning identity, infrastructure, applications, and external services.

Data Validation

Detect orphaned relationships, missing references, and circular dependencies with severity categorization.

​
Component Types

The tool supports the following component types:
TypeDescriptionExamples
Identity ProviderAuthentication and directory servicesActive Directory, Azure AD, Okta, ADFS
DatabaseData stores and warehousesSQL Server, Oracle, PostgreSQL, MongoDB
BackendCore infrastructure and computeHypervisors (VMware, Hyper-V), Kubernetes clusters, physical servers
GatewayNetwork and security appliancesFirewalls, load balancers, VPN concentrators, reverse proxies
APIInternal and external API servicesREST APIs, SOAP services, GraphQL endpoints
QueueMessage brokers and event systemsRabbitMQ, Kafka, MSMQ, Azure Service Bus
CacheCaching and session layersRedis, Memcached, distributed caches
FrontendUser-facing applicationsWeb portals, client applications, admin consoles
ExternalThird-party and cloud servicesSaaS applications, cloud providers, partner integrations

​
Relationship Types

Seven relationship types characterize component connections:
  • depends_on - Component requires another to function (e.g., application depends on database)
  • communicates_with - Bidirectional communication (e.g., app servers in a cluster)
  • authenticates_via - Authentication dependency (e.g., application authenticates via Active Directory)
  • reads_from - Data consumption (e.g., reporting server reads from data warehouse)
  • writes_to - Data production (e.g., application writes to audit database)
  • publishes - Event publishing (e.g., service publishes to message queue)
  • subscribes - Event subscription (e.g., processor subscribes to event stream)
Edges are color-coded by relationship type for quick visual identification of dependency patterns.

​
Use Cases

​
Change Management

Before modifying infrastructure, visualize the blast radius:
  1. Select the component you plan to change
  2. Expand dependencies to see all affected systems
  3. Identify which teams and services need to be notified
  4. Plan maintenance windows based on dependency criticality

​
Security Analysis

Map authentication and trust relationships:
  • Trace which systems authenticate against each domain controller
  • Identify single points of failure in identity infrastructure
  • Document network segmentation and trust boundaries
  • Support tier model implementation by visualizing cross-tier dependencies

​
Incident Response

During outages, quickly identify root cause:
  • Start from the affected service and trace upstream
  • Identify shared dependencies that could cause correlated failures
  • Document the incident path for post-mortems

​
Prerequisites

Before installing, ensure you have:
  • Node.js 18+
  • Rust 1.70+
  • Tauri platform-specific dependencies

​
Installation

​
Development

git clone https://github.com/AlchemicalChef/DependencyMappingTool.git
cd DependencyMappingTool
npm install
npm run tauri dev

​
Production Build

npm run tauri build
The build output will be located in the src-tauri/target/release directory.

​
Getting Started

1

Create an Environment

Start by creating your first environment (e.g., “production” or “datacenter-east”). Each environment maintains isolated component configurations.
2

Add Components

Define your infrastructure components by specifying the type, version, owner, team, and any relevant tags or custom metadata.
3

Define Relationships

Connect components by creating relationships that describe how they interact with each other.
4

Explore the Graph

Use the interactive visualization to explore your architecture. Click on nodes to focus on specific components and their dependencies.

​
Search and Filtering

The tool provides full-text search across:
  • Component names
  • Descriptions
  • Tags
  • Owners
You can also filter the graph view by:
  • Component type
  • Health status
  • Relationship type

​
Tech Stack

LayerTechnologies
FrontendReact 18, TypeScript, Chakra UI, Cytoscape.js, Zustand
BackendRust, Tauri 2.0
DataJSON file storage per environment

​
Resources