Actionable ChatGPT Prompts for Product Dependency Identification & Mapping
Identifying product dependencies is critical for smooth project execution, yet often complex and time-consuming. Leverage these expert-crafted ChatGPT prompts to efficiently map technical, data, and team dependencies, reducing risks and improving your planning accuracy. ChatBoost helps you streamline this essential analysis directly within ChatGPT.
Kickstart the dependency mapping process for a new feature by brainstorming across key categories.
Given the feature specification for '[Feature Name]', brainstorm a comprehensive list of potential dependencies. Organize them into three categories: Technical (e.g., microservices, libraries, infrastructure), Data (e.g., databases, APIs, data warehouses), and Team (e.g., other squads, legal, marketing).
Codebase Dependency Analysis
Analyze a code snippet to automatically identify all external library and framework dependencies.
Identify external libraries and frameworks within this code snippet from our '[Component Name]' component. For each, state its purpose and version (if specified). Code: `[Paste code snippet here]`
Microservice Interaction Map
Map out how different microservices interact for a specific user flow to visualize the call chain.
For the '[User Flow, e.g., 'user checkout']' process, describe the sequence of microservice interactions. List each service, its API calls (made/received), and data exchanged. Present this as a chronological numbered flow.
API Endpoint Dependency Check
Identify all internal services, databases, or data sources that a specific API endpoint relies on.
For the API endpoint `[e.g., GET /api/v2/users/{id}/profile]`, list all downstream dependencies. Include databases, other microservices, caching layers, and any third-party APIs required to fulfill the request.
Database Schema Dependency
Find both explicit and implicit dependencies between tables in a database schema.
Given the following two database table schemas, identify all foreign key relationships and other implicit dependencies (e.g., business logic dependencies) between them. Schema A: `[Paste Schema A]` Schema B: `[Paste Schema B]`
Cross-Team Feature Dependency
Clarify which internal teams are required to successfully deliver a complex, cross-functional feature.
To launch '[Feature Name]' (key requirements: [List 2-3 key requirements]), identify all internal teams (e.g., Platform, Mobile, Data Science, Legal, Marketing) with dependencies. Describe their required contribution.
Third-Party Service Risk
Assess the potential risks and failure points associated with relying on an external third-party service.
We are integrating '[Third-Party Service Name]' for '[Functionality, e.g., payment processing]'. Create a risk assessment table identifying dependencies and risks (e.g., API rate limits, outages, data privacy, cost scaling).
Generate Mermaid Sequence Diagram
Create a sequence diagram in Mermaid syntax to visually map a process flow between systems.
Generate a Mermaid sequence diagram illustrating the dependency flow for a user password reset. The actors are User, Frontend, Auth Service, and Email Service. Show the API calls and responses between them in the correct order.
Data Source Mapping
Trace where the data for a specific UI component originates, from the frontend back to the database.
The '[UI Component Name, e.g., 'User Dashboard']' displays these data points: [List data points]. For each, trace its likely origin back to a specific API endpoint and the underlying database table or data source.
Identify Single Points of Failure
Analyze a system architecture description to proactively find potential single points of failure.
Based on this system architecture description, identify potential single points of failure (SPOFs). For each identified SPOF, explain why it's a risk and suggest a high-level mitigation strategy (e.g., redundancy, fallback, circuit breaker). Architecture: `[Paste architecture overview]`
Upstream/Downstream Dependency List
Differentiate between upstream (it relies on) and downstream (relies on it) dependencies for a service.
For our '[Service Name, e.g., 'Pricing Service']', create two lists: 1. Upstream Dependencies (services, databases, or APIs it relies on). 2. Downstream Dependencies (services, clients, or features that rely on it).
Feature Flag Dependencies
Outline all technical and team-related dependencies for managing a feature behind a feature flag.
We are releasing '[New Feature]' behind a feature flag. Outline the key dependencies for a successful rollout, considering client/server-side flags, analytics tracking, and marketing coordination.
Dependency Impact Analysis
Analyze the potential blast radius and impact of a breaking change in a shared component or library.
We must introduce a breaking change to our '[Shared Component/Library Name]'. Based on its core function, list all the product features and teams that would likely be impacted and need to perform updates. Categorize the impact level as High, Medium, or Low for each.
Generate Graphviz Dot File
Create a dependency graph in Dot language syntax for easy visualization with Graphviz.
Generate a dependency graph in Graphviz Dot language syntax. The nodes are: 'WebApp', 'API Gateway', 'UserService', 'ProductService', 'PostgreSQL'. Show the directed dependencies between them based on a typical e-commerce architecture.
External Team Handoffs
Detail the critical information and artifacts required for a smooth handoff to a dependent team.
My team, '[Your Team Name]', is finishing '[Component/Service Name]'. The '[Receiving Team Name]' depends on this. Create a comprehensive checklist of key information and artifacts for the handoff (e.g., API docs, deployment scripts, contacts, known issues).
Data Transformation Dependencies
Map the dependencies within a complex data pipeline or ETL process to understand data lineage.
Analyze the data transformation: Raw data from '[Source System]' is processed by '[Script/Job Name]' and loaded into '[Data Warehouse Table]'. Identify implicit dependencies like schema contracts, job scheduling order, and data quality checks.
Infrastructure Dependencies
List all the core infrastructure components and services a new microservice will depend on.
For a new microservice, '[Service Name]', list the core infrastructure dependencies required for its build, deployment, and monitoring. Include CI/CD, container orchestration (e.g., Kubernetes), logging/monitoring tools, and cloud services (e.g., S3, RDS).
Legal & Compliance Dependencies
Identify potential legal, security, or compliance reviews needed for a feature handling sensitive data.
Our new feature, '[Feature Name]', collects user data: [List types of data, e.g., location, user-generated content]. What are the likely legal and compliance dependencies? (e.g., GDPR review, TOS update, security audit).
Create a Dependency Matrix
Structure project dependencies in a clear matrix format for at-a-glance project planning.
Create a dependency matrix for '[Project Name]'. Use these features as rows: '[Feature A]', '[Feature B]', '[Feature C]'. Use these shared components/services as columns: '[Auth Service]', '[Database]', '[UI Kit]'. Mark 'X' where a dependency exists.
Version Dependency Conflict
Identify potential conflicts arising from different services depending on different versions of the same library.
Service A depends on `LibraryX v1.5`. Service B, which needs to integrate with Service A, depends on `LibraryX v2.2`. What are the potential dependency conflicts and risks here (e.g., 'diamond dependency problem')? Suggest 2-3 strategies to resolve this.
Environmental Dependencies
Differentiate dependencies across development, staging, and production environments to avoid surprises.
For '[Application Name]', list dependencies that may differ across development, staging, and production environments. Consider API keys, database connection strings, third-party service endpoints (sandbox vs. production), and feature flag configurations.
Identify Critical Path
Analyze a list of tasks and their dependencies to determine the project's critical path.
Given these tasks and their dependencies for '[Project Name]', identify the critical path and total minimum project duration. Tasks: Task A (3 days), Task B (2 days, depends on A), Task C (4 days, depends on A), Task D (2 days, depends on B and C).
Marketing & Sales Dependencies
Brainstorm dependencies on non-technical teams required for a successful product launch.
For the '[Feature Name]' launch on [Date], identify key dependencies on Marketing and Sales. Create a checklist including blog posts, help documentation, sales training materials, and press releases.
Dependency Communication Plan
Draft a clear communication plan for informing dependent teams about a change in a shared service.
We are deprecating `API v1` of our '[Service Name]' in 3 months. Draft a communication plan for downstream teams, including milestones, channels (email, Slack), required actions, and points of contact.
Reverse Dependency Lookup
From a single database table, infer which application features and services might depend on it.
Given the database table schema for `[Table Name, e.g., 'user_subscriptions']`, brainstorm application features that likely depend on this data. For each feature, explain the nature of the dependency (read, write, or both).
Hardware Dependency Analysis
Identify specific hardware dependencies or minimum requirements for a resource-intensive application feature.
Our new feature involves '[Feature Description, e.g., real-time 3D rendering]'. Identify potential hardware dependencies or minimum requirements for correct client-side function (CPU, GPU, RAM, peripherals like webcams or microphones).
Turn these prompts into a reusable workspace
Save your favourite prompts once, reuse them with Alt+P, keep a live Table of Contents of long chats, and export conversations when you're done.
