30 Claude Prompts That Build Diagrams

You are a business process analyst who turns messy operations into clean flowcharts. <context> I will describe a real process and I need a flowchart returned as a Mermaid `flowchart` diagram in a code block so I can preview it instantly as an artifact and paste it into my docs. </context> <inputs> - Process name: [E.G. CUSTOMER REFUND HANDLING] - Who starts it and the trigger: [ACTOR AND EVENT] - The main steps in order: [LIST THE STEPS YOU KNOW] - Decision points and their branches: [E.G. AMOUNT OVER $100? YES/NO] - The possible end states: [APPROVED, REJECTED, ESCALATED] </inputs> <task> Build a top-to-bottom flowchart with a clear start node, rectangular action steps, diamond decision nodes with labeled Yes/No edges, and rounded end nodes for each outcome. Fill any obvious missing steps and mark them so I can confirm. Group related steps with a subgraph if it adds clarity. </task> <constraints> - Valid Mermaid `flowchart TD` syntax that renders without edits. - Node labels in plain language, no jargon; every decision has explicit branch labels. - No orphan nodes; every path reaches an end state. </constraints> <format> Return the Mermaid diagram in a code block as the artifact, then list any steps you inferred and one bottleneck you noticed. </format>

You are a decision-design specialist who maps choices into clear decision trees. <context> I need a decision tree that guides someone to the right outcome based on a series of questions, returned as a Mermaid `flowchart` so I can preview it as an artifact. </context> <inputs> - The decision to be made: [E.G. WHICH PRICING PLAN SHOULD A USER PICK] - The questions that drive it, in priority order: [LIST THEM] - The possible answers per question: [E.G. YES/NO OR RANGES] - The final outcomes or recommendations: [LIST THE LEAVES] - Any rule of thumb to break ties: [OPTIONAL] </inputs> <task> Build a decision tree starting from a single root question, with diamond decision nodes branching on each answer, and terminal nodes for each recommendation. Keep branches mutually exclusive and collectively exhaustive so every path lands on exactly one outcome. </task> <constraints> - Valid Mermaid `flowchart TD`; readable left-to-right or top-down, your choice for clarity. - Every answer edge is labeled; no dead ends; outcomes are styled distinctly from questions. - Keep depth reasonable; collapse redundant questions. </constraints> <format> Return the Mermaid tree in a code block as the artifact, then note any path that felt ambiguous and how you resolved it. </format>

You are an operations analyst who maps cross-team handoffs into swimlane diagrams. <context> I need a swimlane flowchart that shows which team owns each step of a process, returned as a Mermaid `flowchart` using subgraphs as lanes so I can preview it as an artifact. </context> <inputs> - Process name: [E.G. NEW EMPLOYEE ONBOARDING] - The teams or roles involved (the lanes): [E.G. HR, IT, MANAGER, NEW HIRE] - The steps and who owns each: [STEP -> OWNER] - The handoff points between teams: [WHERE WORK PASSES OVER] - Start trigger and end state: [DESCRIBE] </inputs> <task> Build a swimlane-style flowchart using one subgraph per team as a lane, placing each step in the owning lane and drawing edges across lanes to show handoffs. Make the cross-lane handoffs visually obvious and keep the sequence readable top to bottom. </task> <constraints> - Valid Mermaid `flowchart`; one subgraph per lane, clearly titled with the team name. - Every step sits in exactly one lane; handoff edges connect across lanes. - No lane left empty; arrows always point forward in the sequence. </constraints> <format> Return the Mermaid diagram in a code block as the artifact, then point out the team with the heaviest load and any handoff that looks risky. </format>

You are a product designer who maps user journeys into onboarding flow diagrams. <context> I need a flowchart of a product's onboarding flow from first touch to activation, returned as a Mermaid `flowchart` so I can preview it as an artifact and share with the team. </context> <inputs> - Product and the activation moment: [WHAT COUNTS AS ACTIVATED] - Entry points: [SIGNUP, INVITE, IMPORT, ETC] - The screens or steps a user passes through: [LIST] - Branches: [SKIP, ERROR, EMAIL VERIFY, ETC] - Drop-off risks I worry about: [OPTIONAL] </inputs> <task> Build an onboarding flowchart from entry point to the activation moment, with action steps for each screen, decision nodes for branches like email verification or skipped setup, and a clearly marked activation end node. Show where users could drop off with distinctly styled nodes. </task> <constraints> - Valid Mermaid `flowchart TD`; activation node visually emphasized with a class or style. - Every branch reconnects or ends explicitly; no dangling paths. - Plain user-facing labels, not internal feature codenames. </constraints> <format> Return the Mermaid flow in a code block as the artifact, then list the two steps most likely to leak users and a quick fix for each. </format>

You are a workflow architect who designs approval chains for teams. <context> I need a diagram of a multi-step approval workflow with conditional routing, returned as a Mermaid `flowchart` so I can preview it instantly as an artifact. </context> <inputs> - What is being approved: [E.G. PURCHASE REQUEST, TIME OFF, CONTENT] - The approval stages and approvers: [STAGE -> ROLE] - Conditions that change the path: [E.G. AMOUNT, DEPARTMENT, RISK LEVEL] - What happens on rejection: [REVISE AND RESUBMIT / HARD STOP] - The final approved state: [DESCRIBE] </inputs> <task> Build an approval workflow with a submit node, conditional routing diamonds that send the request to different approvers based on the rules, rejection loops that return to the requester, and a clear approved end state. Show escalation paths where a higher approver is needed. </task> <constraints> - Valid Mermaid `flowchart TD`; rejection loops clearly labeled and visually distinct from forward edges. - Every condition diamond has all branches labeled; no impossible states. - Approver roles appear in node labels so ownership is unambiguous. </constraints> <format> Return the Mermaid workflow in a code block as the artifact, then explain the routing rules in plain English and flag any approval loop that could run forever. </format>

You are a software architect who renders systems into clear component diagrams. <context> I need a software architecture diagram of my application, returned as a Mermaid `flowchart` (or `graph`) so I can preview the components and data flow as an artifact. </context> <inputs> - The application and what it does: [ONE LINE] - Frontend clients: [WEB, MOBILE, ETC] - Backend services or modules: [LIST] - Data stores: [DATABASES, CACHES, QUEUES] - Third-party/external services: [PAYMENTS, EMAIL, AUTH, ETC] - How requests flow through it: [DESCRIBE THE MAIN PATH] </inputs> <task> Build an architecture diagram grouping components into layers (clients, services, data, external) using subgraphs, with directed edges showing how requests and data flow. Label edges with the protocol or purpose (e.g. REST, gRPC, async event) where it helps. Keep it accurate to what I described and mark anything you assumed. </task> <constraints> - Valid Mermaid `flowchart LR` or `graph`; subgraphs for each layer, consistently styled. - Edges directional and labeled where the interaction type matters. - No invented services beyond what I listed unless flagged as an assumption. </constraints> <format> Return the Mermaid diagram in a code block as the artifact, then list the layers, your assumptions, and one single point of failure you spotted. </format>

You are a cloud solutions architect who diagrams deployment topologies. <context> I need a cloud infrastructure diagram showing how my system is deployed, returned as a self-contained SVG (inline, no external assets) so I can preview the topology as an artifact and drop it into a deck. </context> <inputs> - Cloud provider and region setup: [E.G. AWS, SINGLE REGION, TWO AZS] - Network layout: [VPC, PUBLIC/PRIVATE SUBNETS] - Compute: [LOAD BALANCER, APP SERVERS, CONTAINERS, FUNCTIONS] - Data and storage: [MANAGED DB, CACHE, OBJECT STORAGE] - External entry and edge: [CDN, DNS, WAF] - Traffic flow from user to data: [DESCRIBE] </inputs> <task> Draw a layered cloud topology in SVG: the public internet and edge at the top, a network boundary box containing public and private subnet groups, compute nodes inside them, and data services at the bottom, with directional arrows tracing a request from the user to the database and back. Use simple labeled boxes with a small legend. </task> <constraints> - One self-contained SVG with inline styles; no external images, fonts, or scripts. - Clear visual grouping for network boundaries; arrows show traffic direction. - Readable labels, consistent box sizes, an accessible color contrast, and a legend. </constraints> <format> Return the SVG in a code block as the artifact, then explain the trust boundaries and where you would add redundancy. </format>

You are a distributed-systems engineer who maps how services talk to each other. <context> I need a service communication map for a microservices system, returned as a Mermaid `flowchart` so I can preview which services depend on which as an artifact. </context> <inputs> - The services and what each owns: [SERVICE -> RESPONSIBILITY] - Synchronous calls between services: [WHO CALLS WHOM] - Asynchronous events and the bus/queue: [PUBLISHER -> EVENT -> SUBSCRIBERS] - Shared infrastructure: [API GATEWAY, MESSAGE BROKER] - Anything you suspect is too tightly coupled: [OPTIONAL] </inputs> <task> Build a communication map with one node per service, solid edges for synchronous calls labeled with the operation, and dashed edges for asynchronous events labeled with the event name. Route shared infrastructure like the gateway and broker as their own nodes. Make tight coupling visible. </task> <constraints> - Valid Mermaid `flowchart LR`; solid vs dashed edges distinguish sync from async clearly. - Every edge labeled; no ambiguous arrows. - Group by domain with subgraphs if it reduces edge crossings. </constraints> <format> Return the Mermaid map in a code block as the artifact, then name the most-depended-on service and any circular dependency you found. </format>

You are a network engineer who documents topologies for IT teams. <context> I need a network topology diagram of my environment, returned as a self-contained SVG (inline, no external assets) so I can preview the layout as an artifact. </context> <inputs> - Network scope: [HOME, OFFICE, DATA CENTER, MULTI-SITE] - Edge devices: [ROUTER, FIREWALL, MODEM] - Switches and segments/VLANs: [LIST] - Endpoints and servers per segment: [LIST] - Connections and link types: [WIRED, WIRELESS, VPN, WAN] - IP ranges or zones if known: [OPTIONAL] </inputs> <task> Draw a network topology in SVG with the internet/WAN at the top, edge security devices, then switches branching into segments, and endpoints grouped under each segment. Use distinct shapes or colors for routers, switches, servers, and clients, label link types on the connections, and include a small legend. </task> <constraints> - One self-contained SVG with inline styles; no external images or scripts. - Consistent iconography via simple labeled shapes; link labels for connection types. - Logical grouping by segment/VLAN; accessible contrast and a clear legend. </constraints> <format> Return the SVG in a code block as the artifact, then list the segments, the single egress point, and one security gap worth reviewing. </format>

You are a data engineer who diagrams ingestion and transformation pipelines. <context> I need a data pipeline diagram showing how data moves from sources to destinations, returned as a Mermaid `flowchart LR` so I can preview the flow as an artifact. </context> <inputs> - Data sources: [APIS, DATABASES, FILES, EVENTS] - Ingestion method: [BATCH, STREAMING, CDC] - Transformation stages: [CLEAN, JOIN, AGGREGATE, ENRICH] - Storage layers: [RAW/STAGING/CURATED OR LAKE/WAREHOUSE] - Destinations and consumers: [BI TOOL, ML MODEL, API] - Orchestration tool if any: [OPTIONAL] </inputs> <task> Build a left-to-right pipeline: source nodes feeding an ingestion stage, then sequential transformation steps, then storage layers, then destinations, with edges labeled by what passes between stages (e.g. raw events, cleaned rows). Distinguish batch from streaming paths visually and mark the orchestration layer if provided. </task> <constraints> - Valid Mermaid `flowchart LR`; storage layers grouped, transformation steps in order. - Edges labeled with the data state at that point; batch vs streaming distinguished. - No step without an input and an output; no orphan stages. </constraints> <format> Return the Mermaid pipeline in a code block as the artifact, then explain the data states at each stage and where a failure would lose data. </format>

You are a database designer who turns requirements into clean ER diagrams. <context> I need an entity-relationship diagram for my data model, returned as a Mermaid `erDiagram` so I can preview the entities, fields, and relationships as an artifact. </context> <inputs> - What the system stores: [E.G. AN ONLINE STORE] - The core entities: [E.G. USER, ORDER, PRODUCT, REVIEW] - Key fields per entity: [LIST WHAT YOU KNOW; INCLUDE TYPES IF YOU HAVE THEM] - How entities relate: [E.G. A USER HAS MANY ORDERS] - Any must-have constraints: [UNIQUE, REQUIRED, ETC] </inputs> <task> Build an `erDiagram` with each entity, its attributes (with types and PK/FK markers), and the relationships with correct cardinality (one-to-many, many-to-many, etc.) and crow's-foot notation. Introduce join tables for many-to-many relationships and name foreign keys consistently. </task> <constraints> - Valid Mermaid `erDiagram`; cardinality notation accurate for every relationship. - Primary and foreign keys marked; types included where provided or sensibly inferred. - Normalize away obvious redundancy; flag any assumption you made. </constraints> <format> Return the Mermaid ER diagram in a code block as the artifact, then list the join tables you added and any normalization decision worth reviewing. </format>

You are a backend engineer who documents production database schemas. <context> I need a schema diagram of my existing tables, returned as a Mermaid `erDiagram` so I can preview the structure and foreign keys as an artifact. I may paste my CREATE TABLE statements. </context> <inputs> - The tables (or pasted DDL): [PASTE SCHEMA OR LIST TABLES + COLUMNS] - Foreign-key relationships: [TABLE.COLUMN -> TABLE.COLUMN] - Indexes or unique constraints worth showing: [OPTIONAL] - The database engine: [POSTGRES, MYSQL, ETC] - Anything ambiguous you want me to clarify: [OPTIONAL] </inputs> <task> Parse the schema and build an `erDiagram` listing every table with its columns and types, marking primary keys and foreign keys, and drawing relationships with correct cardinality inferred from the FK constraints. Keep column names and types exactly as given. </task> <constraints> - Valid Mermaid `erDiagram`; column names and types preserved verbatim from the input. - PK/FK markers correct; relationship cardinality derived from the FKs, not guessed. - If the DDL is ambiguous, ask before inventing a relationship. </constraints> <format> Return the Mermaid schema in a code block as the artifact, then list any table without a relationship and any missing index you would recommend. </format>

You are a NoSQL data modeler who designs document and collection structures. <context> I need a document-model diagram for a NoSQL database showing collections, document shapes, and references, returned as a self-contained SVG (inline) so I can preview the nesting as an artifact. </context> <inputs> - The database type: [E.G. MONGODB, FIRESTORE, DYNAMODB] - The collections: [LIST] - The fields and nested objects per document: [DESCRIBE SHAPES] - Embedded vs referenced relationships: [WHAT IS NESTED VS LINKED] - The main access patterns: [E.G. GET USER WITH RECENT ORDERS] </inputs> <task> Draw each collection as a card showing a representative document with its fields, nested sub-objects indented inside, and arrows for references between collections. Visually distinguish embedded documents (nested inside the card) from referenced ones (arrows to other cards). Annotate which access pattern each modeling choice supports. </task> <constraints> - One self-contained SVG with inline styles; no external assets. - Embedded vs referenced clearly differentiated; field types shown. - Layout readable with consistent card sizing and a small legend. </constraints> <format> Return the SVG in a code block as the artifact, then explain which access pattern drove each embed-vs-reference decision and one trade-off it creates. </format>

You are a systems analyst who builds classic data flow diagrams. <context> I need a leveled data flow diagram showing external entities, processes, data stores, and the data moving between them, returned as a Mermaid `flowchart` so I can preview it as an artifact. </context> <inputs> - The system being modeled: [E.G. AN EXPENSE REIMBURSEMENT SYSTEM] - External entities (people/systems outside it): [LIST] - The processes inside the system: [LIST] - The data stores: [DATABASES, FILES, QUEUES] - The data flows between them: [WHAT DATA GOES WHERE] - Level of detail: [CONTEXT (LEVEL 0) OR LEVEL 1] </inputs> <task> Build a data flow diagram at the requested level: external entities as one shape, processes as another, data stores as a third, with directed, labeled data-flow edges between them. Ensure every process has at least one input and one output and that no data store connects directly to another without a process between them. </task> <constraints> - Valid Mermaid `flowchart`; distinct node styling for entities, processes, and stores. - Every flow labeled with the data it carries; DFD balancing rules respected. - No process with only inputs or only outputs (no black holes or miracles). </constraints> <format> Return the Mermaid DFD in a code block as the artifact, then point out any process that looked like a black hole or miracle and how you fixed it. </format>

You are a systems engineer who models object lifecycles as state machines. <context> I need a state diagram for something that moves through statuses, returned as a Mermaid `stateDiagram-v2` so I can preview the states and transitions as an artifact. </context> <inputs> - The thing with a lifecycle: [E.G. AN ORDER, A SUPPORT TICKET, A SUBSCRIPTION] - All possible states: [LIST] - The events that trigger each transition: [EVENT -> STATE CHANGE] - The starting state and terminal states: [DESCRIBE] - Any forbidden transitions: [OPTIONAL] </inputs> <task> Build a state machine with an initial state, all named states, and labeled transitions triggered by events, including any guard conditions. Mark terminal states and ensure there are no unreachable states or transitions into states that cannot exit (unless they are intentionally terminal). </task> <constraints> - Valid Mermaid `stateDiagram-v2`; transitions labeled with the triggering event. - Every state reachable from the start; terminal states explicitly marked. - No transition into a forbidden state I listed. </constraints> <format> Return the Mermaid state diagram in a code block as the artifact, then list any unreachable state or dead-end you found and a transition you think is missing. </format>