Understanding Microservice Dependencies: A Complete Taxonomy from 2,659 Sources

In microservice architectures, dependencies are the invisible threads that hold everything together—and when they break, your entire system can unravel. Yet despite their critical importance, there's been no unified framework for understanding, categorizing, and managing these dependencies.

Our multivocal literature review—published in the Journal of Systems and Software (JSS)—synthesized 2,659 sources (1,733 academic papers + 926 grey literature articles) to create the first comprehensive taxonomy of microservice dependencies. We identified 28 distinct dependency types across 6 categories, plus 11 symptom patterns that indicate underlying dependency issues.

The Big Picture

Before diving into details, here's how the 90 synthesized studies map across dependency types, tools, and quality impacts:

The flow reveals a critical insight: Control Dependencies dominate research attention, while Semantic and Quality Attribute Dependencies remain underexplored—despite their significant impact on system maintainability.

The Unified Dependency Taxonomy

We developed a comprehensive taxonomy that organizes all identified dependencies into 6 primary categories and 4 symptom categories. This framework provides a common vocabulary for both researchers and practitioners.

The 6 Primary Dependency Categories (D1-D6)

Understanding Each Dependency Category

D1. Data Dependency

Data dependencies arise when microservices share or interact with common data entities.

Data Schema Dependency occurs when multiple services interact with overlapping database schemas or data transfer objects (DTOs). Changes to schema design can cascade across all dependent services.

Parametric Dependency describes how input parameters influence service behavior and inter-service communication. Configuration changes can silently break downstream services.

D2. Control Dependency

Control dependencies govern how services interact and coordinate their execution.

D3. Resource Dependency

Resource dependencies (also called Technology Dependencies) occur when services share infrastructure or code resources.

• Source Code Dependency: Shared libraries between services
• Database Dependency: Multiple services accessing the same database instance
• Environment Dependency: Configuration settings, credentials, environment variables
• Cluster Dependency: Services relying on specific containerized environments (Docker, Kubernetes pods)
• Network Dependency: Reliance on network protocols (HTTP, gRPC, message queues)

D4. Semantic Dependency

Semantic dependencies emerge from functional similarities between services. Services performing similar tasks may need coordinated updates to maintain consistency across the system.

D5. Quality Attributes Dependency

These dependencies relate to non-functional requirements:

• Security: Authentication, authorization, encryption dependencies
• SLA Requirements: Performance, availability, and reliability constraints

D6. Requirement Dependency

Functional dependencies based on business process flows, often mapped using Domain-Driven Design (DDD) principles.

Dependency Symptoms (S1-S4)

Beyond the primary categories, we identified symptom patterns—manifestations of underlying dependencies that indicate potential issues.

Tools for Industry Practitioners

Our review identified 20+ tools for dependency detection and management. Here are the most useful ones organized by use case:

Dependency Analysis & Visualization

Root Cause Analysis & Fault Diagnosis

Resource Management & Autoscaling

Industry-Grade Observability Platforms

Impact on Software Quality

Our review examined how dependencies affect key quality attributes:

Practical Recommendations

For Architects and Team Leads

1. Map dependencies early — Use tools like GSMART or MicroDepGraph during design reviews
2. Classify by criticality — Distinguish hard vs. soft dependencies to prioritize resilience efforts
3. Monitor coupling evolution — Tools like SYMBIOTE can detect architectural degradation before it becomes critical
4. Adopt interface-first development — Define contracts before implementation to prevent hidden dependencies

For Developers

1. Avoid shared databases — Expose data through dedicated services with REST APIs
2. Prefer asynchronous communication — Reduces temporal coupling and improves resilience
3. Use feature flags for gradual rollouts — Enables backward-compatible API evolution
4. Implement circuit breakers — Prevents cascading failures from dependency issues

For DevOps Teams

1. Integrate dependency scanning into CI/CD — Catch issues before deployment
2. Use observability platforms — New Relic, Ortelius, or OpenTelemetry for runtime dependency tracking
3. Containerize with clear dependency boundaries — Explicit Dockerfile and Kubernetes manifests
4. Automate dependency updates — But with careful testing to prevent breaking changes

Benchmarks for Testing

The research community has developed several benchmarks for testing dependency-related tools:

Open Challenges

Despite significant progress, several challenges remain:

1. Automated taxonomy application — No tools yet automatically classify dependencies into our taxonomy
2. Cross-language dependency detection — Most tools focus on single languages (Java dominates)
3. Runtime vs. design-time gap — Static analysis misses dynamic dependencies; dynamic analysis is resource-intensive
4. Semantic dependency detection — Understanding functional similarities requires advanced NLP/ML approaches
5. Quality attribute integration — Connecting dependencies to SLA violations remains manual

Citation

@article{abdelfattah2025multivocal,
  title={Multivocal study on microservice dependencies},
  author={Abdelfattah, Amr S. and Cerny, Tomas and Chy, Md Showkat Hossain
          and Uddin, Md Arfan and Perry, Samantha and Brown, Cameron
          and Goodrich, Lauren and Hurtado, Miguel and Hassan, Muhid
          and Cai, Yuanfang and Kazman, Rick},
  journal={The Journal of Systems and Software},
  volume={222},
  pages={112334},
  year={2025},
  publisher={Elsevier},
  doi={10.1016/j.jss.2025.112334}
}

About This Research

This work was conducted at the University of Arizona in collaboration with the University of Hawaii and Drexel University. Our team combines expertise in software architecture, microservices, and empirical software engineering.

The paper has been published in the Journal of Systems and Software (JSS), a top-tier software engineering journal. The complete replication package including all synthesized studies and extracted data is available on Zenodo.

Appendix: Complete Tool Reference

For practitioners looking for a comprehensive reference, here's the full catalog of dependency management tools organized by category.

Dependency Analysis Tools

Dependency Visualization Tools

Supporting Frameworks