30 Claude Prompts That Build Flowcharts

You are a solutions architect who documents system architecture as clear diagrams. <context> I need an architecture diagram of my web app, as valid Mermaid code ready to render so new engineers understand how the pieces fit together. </context> <inputs> - App type: [E.G. SAAS, MARKETPLACE, INTERNAL TOOL] - Frontend: [FRAMEWORK / HOSTING] - Backend services: [API, AUTH, WORKERS] - Data stores: [DB, CACHE, QUEUE, STORAGE] - Third-party services: [PAYMENTS, EMAIL, ANALYTICS] </inputs> <task> Build a Mermaid flowchart LR architecture diagram: client at the left, then a subgraph for the application layer (frontend, API, workers), a subgraph for data (DB, cache, queue), and external services on the right. Label every edge with the protocol or purpose (HTTPS, reads/writes, publishes to). Group related components in subgraphs. </task> <constraints> - Valid, renderable Mermaid; quote labels with slashes, parentheses, or arrows in text. - Use subgraphs for logical layers; direction of every arrow reflects real data flow. - Include a legend node explaining shapes or colors used. </constraints> <format> Return the Mermaid code in one block, then note the single point of failure in this design and how to add redundancy. </format>

You are a backend engineer who documents request lifecycles as sequence diagrams. <context> I need a sequence diagram of one important API request end to end, as valid Mermaid code ready to render for the API docs. </context> <inputs> - The request: [E.G. CREATE ORDER, LOGIN, FETCH FEED] - Participants: [CLIENT, API GATEWAY, SERVICE, DB, THIRD PARTY] - Auth mechanism: [JWT, SESSION, API KEY] - Sync vs. async steps: [WHAT HAPPENS IN BACKGROUND] - Error responses: [401, 429, 500, TIMEOUT] </inputs> <task> Build a Mermaid sequenceDiagram showing the full request lifecycle: client to gateway to service to data store and back, including the auth check, any third-party call, and the response. Use alt/opt blocks for error paths (unauthorized, rate limited, downstream failure) and note async steps with a background message. </task> <constraints> - Valid Mermaid sequenceDiagram syntax that renders unedited. - Use activation bars, alt blocks for errors, and notes for async work. - Every participant is declared; messages are labelled with the actual call. </constraints> <format> Return the Mermaid code in one block, then note the slowest hop and where to add caching or a timeout. </format>

You are a DevOps engineer who diagrams build-and-deploy pipelines. <context> I need a diagram of our CI/CD pipeline from commit to production, as valid Mermaid code ready to render for the engineering wiki. </context> <inputs> - Repo and trigger: [E.G. GITHUB PUSH, PR MERGE] - Stages: [LINT, TEST, BUILD, SCAN, DEPLOY] - Environments: [DEV, STAGING, PROD] - Gates: [MANUAL APPROVAL, PASSING TESTS, SCAN CLEAN] - Rollback strategy: [AUTO OR MANUAL] </inputs> <task> Build a Mermaid flowchart LR pipeline: from commit through each CI stage as sequential nodes, quality gates as decision diamonds (tests pass? scan clean? approved?), deploys to each environment, and a rollback branch when a health check fails. Show which stages run in parallel. </task> <constraints> - Valid, renderable Mermaid; quote labels with slashes or parentheses. - Failed gates must route to a fail/notify node, not a dead end. - Parallel stages are grouped so the critical path is clear. </constraints> <format> Return the Mermaid code in one block, then note the longest stage on the critical path and how to speed it up. </format>

You are a data engineer who documents ETL and data-flow pipelines. <context> I need a diagram of my data pipeline from source to dashboard, as valid Mermaid code ready to render so analysts understand where each metric comes from. </context> <inputs> - Data sources: [E.G. APP DB, STRIPE, GA, CSV UPLOADS] - Ingestion method: [BATCH, STREAMING, WEBHOOK] - Transform steps: [CLEAN, JOIN, AGGREGATE, ENRICH] - Warehouse or store: [E.G. BIGQUERY, SNOWFLAKE, POSTGRES] - Consumers: [BI TOOL, ML MODEL, EXPORTS] </inputs> <task> Build a Mermaid flowchart LR data pipeline: sources on the left grouped in a subgraph, an ingestion layer, a transform subgraph showing each step in order, the warehouse, and consumers on the right. Label edges with format or frequency (daily batch, real-time, JSON). Mark where data-quality checks run. </task> <constraints> - Valid Mermaid that renders as-is; quote labels with slashes or parentheses. - Use subgraphs for sources, transforms, and consumers; arrows show real flow direction. - Include at least one data-quality/validation node. </constraints> <format> Return the Mermaid code in one block, then note where a schema change upstream would break things and how to guard it. </format>

You are a distributed-systems architect who maps service-to-service communication. <context> I need a diagram of how my microservices talk to each other, as valid Mermaid code ready to render so the team understands dependencies and blast radius. </context> <inputs> - Services: [LIST SERVICE NAMES AND RESPONSIBILITIES] - Communication style: [REST, GRPC, EVENTS/QUEUE] - Shared infrastructure: [MESSAGE BUS, API GATEWAY, SHARED DB?] - External dependencies: [THIRD-PARTY APIS] - Critical vs. best-effort paths: [WHAT MUST NOT FAIL] </inputs> <task> Build a Mermaid flowchart TD service map: each microservice as a node, synchronous calls as solid labelled edges and asynchronous events as dotted edges through a message-bus node, the API gateway as the entry point, and external dependencies grouped in a subgraph. Highlight the critical path that must not fail. </task> <constraints> - Valid, renderable Mermaid; quote labels with slashes or parentheses. - Distinguish sync (solid) from async (dotted) edges; every edge is labelled. - Flag any shared database as a coupling risk with a note. </constraints> <format> Return the Mermaid code in one block, then note which service has the largest blast radius and how to decouple it. </format>

You are a finance-operations analyst who diagrams approval workflows. <context> I need a flowchart of our expense-approval process, as valid Mermaid code ready to render so employees know exactly who signs off what. </context> <inputs> - Expense types: [TRAVEL, SOFTWARE, EQUIPMENT, ETC] - Amount thresholds: [E.G. UNDER 100 AUTO, 100-1000 MANAGER, 1000+ FINANCE] - Approver roles: [MANAGER, DEPARTMENT HEAD, FINANCE, CFO] - Policy checks: [RECEIPT REQUIRED, BUDGET AVAILABLE] - Rejection handling: [RESUBMIT, ESCALATE] </inputs> <task> Build a Mermaid flowchart TD approval flow: start at expense submitted, policy-check decision (receipt, within budget), amount-threshold decision diamonds routing to the right approver level, approve/reject branches at each level with a resubmit loop, and a reimbursed end node. Show auto-approval for small in-policy amounts. </task> <constraints> - Valid, renderable Mermaid; quote labels with special characters. - Each threshold routes to exactly one approver level; rejections loop back to resubmit. - Auto-approval path is clearly separated from manual review. </constraints> <format> Return the Mermaid code in one block, then note where approvals stall most and how to add an auto-escalate timer. </format>

You are a governance specialist who maps document review and approval workflows. <context> I need a flowchart for reviewing and signing off a document (contract, policy, spec), as valid Mermaid code ready to render for our process wiki. </context> <inputs> - Document type: [CONTRACT, POLICY, SPEC, ETC] - Reviewers in order: [LEGAL, MANAGER, COMPLIANCE, EXEC] - Review outcomes: [APPROVE, REQUEST CHANGES, REJECT] - Version control step: [WHERE EDITS HAPPEN] - Final action: [SIGN, PUBLISH, ARCHIVE] </inputs> <task> Build a Mermaid flowchart TD sign-off flow: start at draft ready, sequential reviewer decision diamonds (each can approve or request changes), a request-changes loop back to the author with a new version, and a final sign/publish node once all approvers pass. Show parallel review where reviewers work simultaneously. </task> <constraints> - Valid Mermaid that renders as-is; quote labels with slashes or parentheses. - Change requests loop back to a revise node, then re-enter review at the right point. - Distinguish sequential from parallel reviews visually. </constraints> <format> Return the Mermaid code in one block, then note whether serial or parallel review is faster here and why. </format>

You are a talent-operations lead who diagrams recruitment approval pipelines. <context> I need a flowchart of our hiring process from open req to signed offer, as valid Mermaid code ready to render for hiring managers and recruiters. </context> <inputs> - Role type: [IC, MANAGER, EXEC] - Stages: [REQ APPROVAL, SCREEN, INTERVIEWS, DEBRIEF, OFFER] - Decision gates: [HEADCOUNT APPROVED, DEBRIEF PASS, OFFER APPROVED] - Approvers: [HIRING MANAGER, RECRUITER, PANEL, FINANCE FOR OFFER] - Rejection points: [WHERE CANDIDATES EXIT] </inputs> <task> Build a Mermaid flowchart TD hiring flow: start at req opened, headcount-approval gate, sourcing and screen, interview loop, debrief decision (advance/reject), offer-approval gate (comp within band?), and signed/declined terminal nodes. Show candidate rejection exits at each stage and the offer-negotiation loop. </task> <constraints> - Valid, renderable Mermaid; quote labels with special characters. - Every stage has a reject/exit branch; offer path includes a comp-approval gate. - Interview and negotiation loops return to the correct node cleanly. </constraints> <format> Return the Mermaid code in one block, then note the slowest gate and how to compress time-to-offer. </format>

You are an IT change-management specialist who diagrams CAB approval processes. <context> I need a flowchart for approving and deploying a production change, as valid Mermaid code ready to render for our change-management policy. </context> <inputs> - Change types: [STANDARD, NORMAL, EMERGENCY] - Risk assessment factors: [BLAST RADIUS, ROLLBACK EASE, TIMING] - Approvers: [CHANGE MANAGER, CAB, ON-CALL LEAD] - Required artifacts: [ROLLBACK PLAN, TEST EVIDENCE] - Post-deploy steps: [VERIFY, MONITOR, CLOSE] </inputs> <task> Build a Mermaid flowchart TD change flow: start at change requested, classify by type (standard = pre-approved, normal = CAB review, emergency = expedited), risk-and-artifact gates, approval decision, scheduled deploy, post-deploy verification with a rollback branch if verification fails, and a closed node. Separate the three change-type lanes clearly. </task> <constraints> - Valid Mermaid that renders unedited; quote labels with slashes or parentheses. - Standard changes skip CAB; emergency changes get retroactive review. - Failed verification always triggers the rollback branch. </constraints> <format> Return the Mermaid code in one block, then note how to keep emergency changes fast without skipping the rollback plan. </format>

You are a financial-planning analyst who maps budget-request and approval workflows. <context> I need a flowchart of how a team requests and gets budget approved, as valid Mermaid code ready to render for the annual planning process. </context> <inputs> - Request context: [NEW SPEND, INCREASE, REALLOCATION] - Amount tiers and approvers: [E.G. MANAGER, DIRECTOR, VP, CFO] - Justification requirements: [BUSINESS CASE, ROI, ALTERNATIVES] - Checks: [WITHIN DEPARTMENT BUDGET? QUARTER TIMING?] - Outcomes: [APPROVED, PARTIAL, DEFERRED, DENIED] </inputs> <task> Build a Mermaid flowchart TD budget flow: start at request submitted, justification-completeness gate (loop back if incomplete), within-budget check, amount-tier decision routing to the right approver, and terminal outcomes (approved, partial, deferred to next quarter, denied). Show the reallocation branch that skips new-spend approval. </task> <constraints> - Valid, renderable Mermaid; quote labels with special characters. - Incomplete requests loop back; each amount tier maps to one approver. - Deferred and partial outcomes are distinct terminal nodes, not merged with denied. </constraints> <format> Return the Mermaid code in one block, then note where requests most often get deferred and how to strengthen the business case earlier. </format>

You are a computer-science educator who explains algorithms as clear flowcharts. <context> I need a flowchart of a sorting algorithm's control flow, as valid Mermaid code ready to render for a lesson or study guide. </context> <inputs> - Algorithm: [E.G. BUBBLE SORT, QUICKSORT, MERGE SORT] - Level of detail: [HIGH-LEVEL STEPS OR EVERY COMPARISON] - Input assumption: [ARRAY OF NUMBERS, SIZE N] - Show complexity notes?: [YES/NO] - Audience: [BEGINNER, INTERVIEW PREP] </inputs> <task> Build a Mermaid flowchart TD of the algorithm's logic: start node, initialization, the main loop(s) with a loop-condition decision diamond, the comparison/swap or partition/recurse steps, and a sorted-output end node. Represent loops with a back-edge to the condition check. Keep node text to short imperative statements. </task> <constraints> - Valid, renderable Mermaid; quote labels containing comparison operators or brackets. - Loop back-edges must return to the condition diamond, not the loop body start. - If complexity notes are requested, add them as a separate note node, not inside logic nodes. </constraints> <format> Return the Mermaid code in one block, then give the time and space complexity and the one line that determines it. </format>

You are a security engineer who diagrams authentication logic for code review. <context> I need a flowchart of my login/authentication logic, as valid Mermaid code ready to render so reviewers can verify the security branches. </context> <inputs> - Auth factors: [PASSWORD, MFA, SSO, MAGIC LINK] - Lockout policy: [FAILED-ATTEMPT LIMIT, RATE LIMIT] - Session handling: [JWT, SESSION COOKIE, REFRESH] - Edge cases: [ACCOUNT LOCKED, UNVERIFIED EMAIL, EXPIRED PASSWORD] - Outcomes: [GRANT, DENY, CHALLENGE MFA, LOCK] </inputs> <task> Build a Mermaid flowchart TD auth logic: start at credentials submitted, validate format, check account status (locked/unverified branches), verify password, MFA-required decision with challenge loop, rate-limit/lockout decision after failed attempts, and terminal nodes for granted, denied, or locked. Make the failure-counting loop explicit. </task> <constraints> - Valid Mermaid that renders as-is; quote labels with special characters. - Every failure path either retries within a limit or locks out; no dead ends. - MFA challenge returns to a verify step; lockout is a distinct terminal state. </constraints> <format> Return the Mermaid code in one block, then note the one branch most likely to hide a security bug and what to test. </format>

You are an ML engineer who diagrams scoring and ranking pipelines. <context> I need a flowchart of how items get scored and ranked for a recommendation, as valid Mermaid code ready to render for a design review. </context> <inputs> - What we recommend: [PRODUCTS, ARTICLES, USERS, ETC] - Candidate generation: [HOW THE INITIAL SET IS BUILT] - Scoring signals: [RELEVANCE, RECENCY, POPULARITY, PERSONALIZATION] - Filters: [ALREADY SEEN, OUT OF STOCK, BLOCKED] - Final step: [RANK, DIVERSIFY, RETURN TOP N] </inputs> <task> Build a Mermaid flowchart TD scoring pipeline: start at request, candidate-generation step, a filtering stage (decision diamonds for each hard filter), a scoring stage combining signals, a re-ranking/diversification step, and a return-top-N end node. Show the fallback branch when too few candidates survive filtering. </task> <constraints> - Valid, renderable Mermaid; quote labels with slashes or parentheses. - Filters run before scoring; the low-candidate fallback path is explicit. - Group signal inputs feeding the scoring node so the formula is legible. </constraints> <format> Return the Mermaid code in one block, then note which signal to tune first to improve relevance and how to A/B test it. </format>

You are a backend engineer who diagrams resilience and retry logic. <context> I need a flowchart of retry-with-exponential-backoff logic for an unreliable call, as valid Mermaid code ready to render for the engineering docs. </context> <inputs> - The operation: [E.G. API CALL, DB WRITE, JOB] - Retry conditions: [WHICH ERRORS ARE RETRYABLE] - Max attempts and backoff: [E.G. 5 TRIES, EXPONENTIAL + JITTER] - Non-retryable errors: [4XX, VALIDATION] - Final failure action: [DEAD-LETTER, ALERT, FALLBACK] </inputs> <task> Build a Mermaid flowchart TD retry logic: start at attempt operation, success/failure decision, on failure classify retryable vs. non-retryable, a max-attempts-reached decision, a wait/backoff node that loops back to the attempt with an incremented counter, and terminal nodes for success, non-retryable failure, and exhausted-retries (dead-letter/alert). Show the backoff calculation as a labelled node. </task> <constraints> - Valid Mermaid that renders unedited; quote labels with operators or parentheses. - Non-retryable errors exit immediately; the counter increments on each loop. - The backoff loop returns to the attempt node, not the start. </constraints> <format> Return the Mermaid code in one block, then note why jitter matters and where a circuit breaker would fit. </format>

You are a computer-science instructor who diagrams search algorithms for learners. <context> I need a flowchart of a search algorithm's logic, as valid Mermaid code ready to render for a tutorial or interview-prep guide. </context> <inputs> - Algorithm: [E.G. BINARY SEARCH, LINEAR SEARCH, BFS, DFS] - Data structure: [SORTED ARRAY, GRAPH, TREE] - Detail level: [CONCEPTUAL OR STEP-BY-STEP] - Target/goal condition: [WHAT WE'RE LOOKING FOR] - Show edge cases?: [EMPTY INPUT, NOT FOUND] </inputs> <task> Build a Mermaid flowchart TD of the search logic: initialization (pointers/queue/visited set), the main loop condition diamond, the comparison or neighbor-visit step that narrows the search or advances, the found-target exit, and a not-found terminal when the search space is exhausted. Represent iteration with a back-edge to the loop condition. </task> <constraints> - Valid, renderable Mermaid; quote labels with comparison operators or brackets. - Include the empty-input and not-found terminal branches. - Loop back-edges return to the condition diamond; keep node text short and imperative. </constraints> <format> Return the Mermaid code in one block, then give the complexity and the invariant that keeps the algorithm correct. </format>