diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000000000000000000000000000000000000..dd7fef1195a0dd60fd86c5a7ae6e86d2250e327c --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,17 @@ +# Contributing + +This repository is synchronized from the FlowZap application template library. + +## Structure + +- `primary-use-case/source-domain/template-slug/` +- `workflow.fz` contains the FlowZap Code source +- `metadata.json` stores machine-readable metadata including primary and secondary Use Cases +- `templates.index.json`, `use-cases.index.json`, and `metadata.csv` are generated artifacts + +## Sync Expectations + +- Keep the sitemap-driven template set aligned with `https://flowzap.xyz/sitemap-templates.xml`. +- Preserve one canonical template copy per slug. +- Use `primary_use_case` for folder placement and `use_cases` for the full taxonomy membership. +- Preserve `source_domain` from the app index for traceability. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..5e9b5b1b15d0791d5715c1d72ebf11bd6e7b9834 --- /dev/null +++ b/LICENSE @@ -0,0 +1,34 @@ +MIT License + +Copyright (c) 2025 FlowZap + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +--- + +## Training Data License Addendum + +This repository is explicitly released for use as training data for Large Language +Models (LLMs) and other machine learning systems. You may: + +- Use this corpus to train, fine-tune, or evaluate AI models +- Include this data in training datasets +- Create derivative datasets based on this corpus + +Attribution is appreciated but not required for training purposes. diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1de53f2fd0850b39c20e4fd8180d2a3e4e7f09e7 --- /dev/null +++ b/README.md @@ -0,0 +1,40 @@ +# sequence-workflows + +A synchronized FlowZap template corpus with **242 canonical templates** sourced from `https://flowzap.xyz/sitemap-templates.xml` and organized by **primary Use Case**. + +## Organization Model + +- Top-level folders are primary Use Cases from the FlowZap Templates dropdown. +- Second-level folders preserve the original source domain from the FlowZap app index. +- Each template keeps all matched Use Cases in `metadata.json` and the generated JSON/CSV indexes. +- Templates that do not match any current dropdown Use Case are placed under `uncategorized/`. + +## Top-Level Folders + +- `handoff/` — Handoff (15) +- `approval/` — Approval (17) +- `incident/` — Incident (10) +- `onboarding/` — Onboarding (6) +- `offboarding/` — Offboarding (1) +- `billing/` — Billing & Payments (8) +- `security/` — Security & Access (13) +- `compliance/` — Compliance (13) +- `delivery/` — Delivery & DevOps (15) +- `support/` — Support (1) +- `agentic/` — Agentic Teams (15) +- `ai-orchestration/` — AI Orchestration (6) +- `mcp/` — MCP Architecture (10) +- `context-management/` — Context Management (6) +- `uncategorized/` — Unmatched canonical templates (106) + +## Generated Indexes + +- `templates.index.json` — Full machine-readable template index +- `use-cases.index.json` — Use Case summary with counts and template paths +- `metadata.csv` — Flat CSV export of core template metadata + +## Sync Source + +- Canonical URL source: `https://flowzap.xyz/sitemap-templates.xml` +- Template metadata source: `FlowZap-App-v5/src/templateLibrary/templatesIndex.json` +- Template file source: `FlowZap-App-v5/public/template-files/*.fz` diff --git a/agentic/architecture/agentic-hierarchical/README.md b/agentic/architecture/agentic-hierarchical/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2c210dbe004c02584d260c62cd350b514b5dbfe9 --- /dev/null +++ b/agentic/architecture/agentic-hierarchical/README.md @@ -0,0 +1,19 @@ +# Agentic Hierarchical Architecture + +A hierarchical multi-agent architecture with multi-level organizational structure. A top-level executive agent manages mid-level team lead agents, who each manage their own pool of specialist workers. Teams within teams — the hierarchy maps to domain separation. + +**Template ID:** `agentic-hierarchical` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 8 +**Lanes:** 7 +**Tags:** [agentic, hierarchical, multi-agent, enterprise, architecture-diagram, ai-team] +**Source path:** `` +**Repo path:** `agentic/architecture/agentic-hierarchical` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/agentic-hierarchical/metadata.json b/agentic/architecture/agentic-hierarchical/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..2cd47bd7a3d472b73f1a81b9a21cd8e8e9312739 --- /dev/null +++ b/agentic/architecture/agentic-hierarchical/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "agentic-hierarchical", + "workflow_id": "agentic-hierarchical", + "title": "Agentic Hierarchical Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [], + "use_cases": [ + "agentic" + ], + "complexity": 4, + "num_nodes": 8, + "num_lanes": 7, + "tags": [ + "agentic", + "hierarchical", + "multi-agent", + "enterprise", + "architecture-diagram", + "ai-team" + ], + "description": "A hierarchical multi-agent architecture with multi-level organizational structure. A top-level executive agent manages mid-level team lead agents, who each manage their own pool of specialist workers. Teams within teams — the hierarchy maps to domain separation.", + "source_path": "", + "repo_path": "agentic/architecture/agentic-hierarchical" +} diff --git a/agentic/architecture/agentic-hierarchical/workflow.fz b/agentic/architecture/agentic-hierarchical/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..5280f8ac4251d02c6015f5e8522cc64554f3434a --- /dev/null +++ b/agentic/architecture/agentic-hierarchical/workflow.fz @@ -0,0 +1,36 @@ +executive_agent {# Executive Agent + n1: rectangle label="Route Master Goal" + n1.handle(bottom) -> research_lead_agent.n2.handle(top) [label="Assign Research"] + n1.handle(bottom) -> content_lead_agent.n5.handle(top) [label="Assign Content"] +} + +research_lead_agent {# Research Lead Agent + n2: rectangle label="Manage Retrieval Team" + n2.handle(bottom) -> web_search_agent.n3.handle(top) [label="Web Task"] + n2.handle(bottom) -> db_retrieval_agent.n4.handle(top) [label="DB Task"] +} + +web_search_agent {# Web Search Agent + n3: rectangle label="Live Web Search" + n3.handle(right) -> research_lead_agent.n2.handle(right) [label="Web Data"] +} + +db_retrieval_agent {# DB Retrieval Agent + n4: rectangle label="Internal Knowledge RAG" + n4.handle(right) -> research_lead_agent.n2.handle(right) [label="Internal Data"] +} + +content_lead_agent {# Content Lead Agent + n5: rectangle label="Manage Production Team" + n5.handle(bottom) -> writer_agent.n6.handle(top) [label="Draft Topic"] +} + +writer_agent {# Writer Agent + n6: rectangle label="Draft Document" + n6.handle(bottom) -> qa_agent.n7.handle(top) [label="Draft Text"] +} + +qa_agent {# QA Agent + n7: rectangle label="Fact Check" + n7.handle(right) -> content_lead_agent.n5.handle(right) [label="Final Content"] +} diff --git a/agentic/architecture/agentic-supervisor-worker/README.md b/agentic/architecture/agentic-supervisor-worker/README.md new file mode 100644 index 0000000000000000000000000000000000000000..38db583dec8909e7e760d109bfa8fff25a0c3812 --- /dev/null +++ b/agentic/architecture/agentic-supervisor-worker/README.md @@ -0,0 +1,19 @@ +# Agentic Supervisor-Worker Architecture + +A supervisor-worker multi-agent architecture where an orchestrator agent receives a high-level goal, breaks it into subtasks, delegates each to specialist worker agents (researcher, writer, QA), monitors execution, handles failures, and synthesizes results. The orchestrator manages but does not execute tasks itself. + +**Template ID:** `agentic-supervisor-worker` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 4 +**Tags:** [agentic, supervisor-worker, multi-agent, orchestrator, architecture-diagram, ai-team] +**Source path:** `` +**Repo path:** `agentic/architecture/agentic-supervisor-worker` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/agentic-supervisor-worker/metadata.json b/agentic/architecture/agentic-supervisor-worker/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..0524addbcee3413597f6da19722a715dbe525683 --- /dev/null +++ b/agentic/architecture/agentic-supervisor-worker/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "agentic-supervisor-worker", + "workflow_id": "agentic-supervisor-worker", + "title": "Agentic Supervisor-Worker Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [], + "use_cases": [ + "agentic" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 4, + "tags": [ + "agentic", + "supervisor-worker", + "multi-agent", + "orchestrator", + "architecture-diagram", + "ai-team" + ], + "description": "A supervisor-worker multi-agent architecture where an orchestrator agent receives a high-level goal, breaks it into subtasks, delegates each to specialist worker agents (researcher, writer, QA), monitors execution, handles failures, and synthesizes results. The orchestrator manages but does not execute tasks itself.", + "source_path": "", + "repo_path": "agentic/architecture/agentic-supervisor-worker" +} diff --git a/agentic/architecture/agentic-supervisor-worker/workflow.fz b/agentic/architecture/agentic-supervisor-worker/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..1c41e316aa13e7ec7745e6641e945115fa13ccb0 --- /dev/null +++ b/agentic/architecture/agentic-supervisor-worker/workflow.fz @@ -0,0 +1,29 @@ +orchestrator_agent {# Orchestrator Agent + n1: rectangle label="Decompose & Manage Subtasks" + n5: diamond label="All Passed QA?" + n6: rectangle label="Synthesize Final Result" + + n1.handle(bottom) -> researcher_agent.n2.handle(top) [label="Task: Gather Sources"] + n1.handle(bottom) -> writer_agent.n3.handle(top) [label="Task: Draft"] + n1.handle(bottom) -> qa_agent.n4.handle(top) [label="Task: Review"] + + n5.handle(right) -> n6.handle(left) [label="Yes"] + n5.handle(top) -> writer_agent.n3.handle(top) [label="No (Fix Draft)"] +} + +researcher_agent {# Research Agent + n2: rectangle label="Retrieve Information (Web/RAG)" + n2.handle(right) -> orchestrator_agent.n1.handle(right) [label="Summary"] +} + +writer_agent {# Writer Agent + n3: rectangle label="Generate Text" + n3.handle(right) -> orchestrator_agent.n1.handle(right) [label="Draft"] +} + +qa_agent {# QA Agent + n4: rectangle label="Review Output" + n4.handle(right) -> orchestrator_agent.n5.handle(left) [label="Flags"] +} + +loop [retry loop] writer_agent.n3 qa_agent.n4 orchestrator_agent.n5 diff --git a/agentic/architecture/agentic-swarm/README.md b/agentic/architecture/agentic-swarm/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2def0d6b2d4ce27005b61ca7a6b843eacf5f8ec5 --- /dev/null +++ b/agentic/architecture/agentic-swarm/README.md @@ -0,0 +1,19 @@ +# Agentic Swarm Architecture + +A swarm multi-agent architecture where multiple agents work on the same or related tasks simultaneously, with no central coordinator. Their outputs are then aggregated, voted on, or merged by a dedicated aggregator node. Agents may compete — the best output wins. + +**Template ID:** `agentic-swarm` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 6 +**Lanes:** 5 +**Tags:** [agentic, swarm, multi-agent, parallel, aggregator, architecture-diagram, ai-team] +**Source path:** `` +**Repo path:** `agentic/architecture/agentic-swarm` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/agentic-swarm/metadata.json b/agentic/architecture/agentic-swarm/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..84c44f7dd20f134c869ad2cb4c11a1caae2db756 --- /dev/null +++ b/agentic/architecture/agentic-swarm/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "agentic-swarm", + "workflow_id": "agentic-swarm", + "title": "Agentic Swarm Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [], + "use_cases": [ + "agentic" + ], + "complexity": 3, + "num_nodes": 6, + "num_lanes": 5, + "tags": [ + "agentic", + "swarm", + "multi-agent", + "parallel", + "aggregator", + "architecture-diagram", + "ai-team" + ], + "description": "A swarm multi-agent architecture where multiple agents work on the same or related tasks simultaneously, with no central coordinator. Their outputs are then aggregated, voted on, or merged by a dedicated aggregator node. Agents may compete — the best output wins.", + "source_path": "", + "repo_path": "agentic/architecture/agentic-swarm" +} diff --git a/agentic/architecture/agentic-swarm/workflow.fz b/agentic/architecture/agentic-swarm/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..7ea3d9d627745c3281aa41e6fa2692eb5796d6f2 --- /dev/null +++ b/agentic/architecture/agentic-swarm/workflow.fz @@ -0,0 +1,25 @@ +dispatcher_agent {# Dispatcher Agent + n1: rectangle label="Split Goals & Dispatch" + n1.handle(bottom) -> research_agent_a.n2.handle(top) [label="Explore Angle 1"] + n1.handle(bottom) -> research_agent_b.n3.handle(top) [label="Explore Angle 2"] + n1.handle(bottom) -> research_agent_c.n4.handle(top) [label="Explore Angle 3"] +} + +research_agent_a {# Research Agent A + n2: rectangle label="Parallel Search A" + n2.handle(bottom) -> aggregator_agent.n5.handle(top) [label="Findings A"] +} + +research_agent_b {# Research Agent B + n3: rectangle label="Parallel Search B" + n3.handle(bottom) -> aggregator_agent.n5.handle(top) [label="Findings B"] +} + +research_agent_c {# Research Agent C + n4: rectangle label="Parallel Search C" + n4.handle(bottom) -> aggregator_agent.n5.handle(top) [label="Findings C"] +} + +aggregator_agent {# Aggregator Agent + n5: rectangle label="Merge & Deduplicate" +} diff --git a/agentic/architecture/agentic-team-of-rivals/README.md b/agentic/architecture/agentic-team-of-rivals/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9cda6526296d5241393557bc7d1055b93e034ce9 --- /dev/null +++ b/agentic/architecture/agentic-team-of-rivals/README.md @@ -0,0 +1,19 @@ +# Agentic Team of Rivals Architecture + +The most architecturally sophisticated multi-agent pattern. Agents are assigned not just roles but opposing incentives. A Planner is optimistic about goal completion. A Critic is constitutionally skeptical and holds veto authority. Errors get caught through adversarial pressure rather than trusting a single model's self-assessment. + +**Template ID:** `agentic-team-of-rivals` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 5 +**Lanes:** 3 +**Tags:** [agentic, team-of-rivals, multi-agent, critic, veto, architecture-diagram, ai-team] +**Source path:** `` +**Repo path:** `agentic/architecture/agentic-team-of-rivals` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/agentic-team-of-rivals/metadata.json b/agentic/architecture/agentic-team-of-rivals/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..fcb7a269514773f3b55603c7d43f1e45ab25f802 --- /dev/null +++ b/agentic/architecture/agentic-team-of-rivals/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "agentic-team-of-rivals", + "workflow_id": "agentic-team-of-rivals", + "title": "Agentic Team of Rivals Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [], + "use_cases": [ + "agentic" + ], + "complexity": 3, + "num_nodes": 5, + "num_lanes": 3, + "tags": [ + "agentic", + "team-of-rivals", + "multi-agent", + "critic", + "veto", + "architecture-diagram", + "ai-team" + ], + "description": "The most architecturally sophisticated multi-agent pattern. Agents are assigned not just roles but opposing incentives. A Planner is optimistic about goal completion. A Critic is constitutionally skeptical and holds veto authority. Errors get caught through adversarial pressure rather than trusting a single model's self-assessment.", + "source_path": "", + "repo_path": "agentic/architecture/agentic-team-of-rivals" +} diff --git a/agentic/architecture/agentic-team-of-rivals/workflow.fz b/agentic/architecture/agentic-team-of-rivals/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6647d61a7b8f4a4d156c444b161d4d20b4b3dbdd --- /dev/null +++ b/agentic/architecture/agentic-team-of-rivals/workflow.fz @@ -0,0 +1,19 @@ +planner_agent {# Planner Agent + n1: rectangle label="Declare Step-by-Step Plan & Acceptance Criteria" + n1.handle(right) -> executor_agent.n2.handle(left) [label="Task Plan + Criteria"] +} + +executor_agent {# Executor Agent + n2: rectangle label="Execute Remote Code & Tools" + n2.handle(right) -> critic_agent.n3.handle(left) [label="Execution Summary"] +} + +critic_agent {# Critic Agent + n3: rectangle label="Validate vs Acceptance Criteria" + n4: diamond label="Passed Gate?" + + n3.handle(bottom) -> n4.handle(top) + n4.handle(top) -> planner_agent.n1.handle(bottom) [label="Veto (Reject & Explain)"] +} + +loop [Rejection Iteration] planner_agent.n1 executor_agent.n2 critic_agent.n3 critic_agent.n4 diff --git a/agentic/architecture/ai-native-event-driven-kafka-architecture/README.md b/agentic/architecture/ai-native-event-driven-kafka-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..33f4617903ab2485c5cf2b0b1fe991d2d67b926e --- /dev/null +++ b/agentic/architecture/ai-native-event-driven-kafka-architecture/README.md @@ -0,0 +1,19 @@ +# AI-Native Event-Driven Kafka Architecture + +An event-driven agentic AI architecture that replaces the central orchestrator with Kafka/PubSub topics: agents subscribe, react, and publish new events. This aligns multi-agent systems with proven microservices choreography and is ideal for real-time, high-throughput systems and 'agent mesh' setups. + +**Template ID:** `ai-native-event-driven-kafka-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration, mcp +**Complexity:** 3/5 +**Nodes:** 12 +**Lanes:** 5 +**Tags:** [ai-native, event-driven, agentic-ai, kafka, pub-sub, agent-mesh, architecture-diagram] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-native-event-driven-kafka-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-native-event-driven-kafka-architecture/metadata.json b/agentic/architecture/ai-native-event-driven-kafka-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f27ba18ac1234b199fcdfca848f8d0950d675170 --- /dev/null +++ b/agentic/architecture/ai-native-event-driven-kafka-architecture/metadata.json @@ -0,0 +1,32 @@ +{ + "template_id": "ai-native-event-driven-kafka-architecture", + "workflow_id": "ai-native-event-driven-kafka-architecture", + "title": "AI-Native Event-Driven Kafka Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration", + "mcp" + ], + "use_cases": [ + "agentic", + "ai-orchestration", + "mcp" + ], + "complexity": 3, + "num_nodes": 12, + "num_lanes": 5, + "tags": [ + "ai-native", + "event-driven", + "agentic-ai", + "kafka", + "pub-sub", + "agent-mesh", + "architecture-diagram" + ], + "description": "An event-driven agentic AI architecture that replaces the central orchestrator with Kafka/PubSub topics: agents subscribe, react, and publish new events. This aligns multi-agent systems with proven microservices choreography and is ideal for real-time, high-throughput systems and 'agent mesh' setups.", + "source_path": "", + "repo_path": "agentic/architecture/ai-native-event-driven-kafka-architecture" +} diff --git a/agentic/architecture/ai-native-event-driven-kafka-architecture/workflow.fz b/agentic/architecture/ai-native-event-driven-kafka-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..96b8f1c26d93599d017c060a386f58d118dff786 --- /dev/null +++ b/agentic/architecture/ai-native-event-driven-kafka-architecture/workflow.fz @@ -0,0 +1,35 @@ +Source { # Event Sources +n1: circle label:"Start" +n2: rectangle label:"User action event" +n3: rectangle label:"System alert event" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Broker.n4.handle(top) [label="Publish event"] +n3.handle(bottom) -> Broker.n4.handle(top) [label="Publish event"] +} +Broker { # Event Broker (Kafka / Pub-Sub) +n4: rectangle label:"Event bus receives event" +n5: rectangle label:"Route to subscribers" +n4.handle(right) -> n5.handle(left) +n5.handle(bottom) -> Orders.n6.handle(top) [label="topic: orders"] +n5.handle(bottom) -> Alerts.n8.handle(top) [label="topic: alerts"] +n5.handle(bottom) -> Analytics.n10.handle(top) [label="topic: analytics"] +} +Orders { # Order Processing Agent +n6: rectangle label:"Parse order event" +n7: rectangle label:"Execute fulfillment" +n6.handle(right) -> n7.handle(left) +n7.handle(bottom) -> Broker.n4.handle(top) [label="Publish: order.completed"] +} +Alerts { # Alert Triage Agent +n8: rectangle label:"Classify severity" +n9: rectangle label:"Route to on-call or auto-resolve" +n8.handle(right) -> n9.handle(left) +n9.handle(bottom) -> Broker.n4.handle(top) [label="Publish: alert.resolved"] +} +Analytics { # Analytics Agent +n10: rectangle label:"Aggregate metrics" +n11: rectangle label:"Update dashboard" +n12: circle label:"Stored" +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) +} diff --git a/agentic/architecture/ai-native-generator-critic-architecture/README.md b/agentic/architecture/ai-native-generator-critic-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0da4cc0f3bc84f6a10b762cc87ae4b4fd24b0525 --- /dev/null +++ b/agentic/architecture/ai-native-generator-critic-architecture/README.md @@ -0,0 +1,19 @@ +# AI-Native Generator-Critic Architecture + +A competitive / generator-critic architecture where multiple generators produce independent answers, then an evaluator agent scores and selects the best output. This approach improves quality and reduces single-model brittleness. It's costlier (multiple LLM calls) but pays off when correctness or creativity matters more than latency. + +**Template ID:** `ai-native-generator-critic-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration +**Complexity:** 3/5 +**Nodes:** 9 +**Lanes:** 3 +**Tags:** [ai-native, generator-critic, agentic-ai, tournament-mode, multi-agent, architecture-diagram] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-native-generator-critic-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-native-generator-critic-architecture/metadata.json b/agentic/architecture/ai-native-generator-critic-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..de3e355c5a158900c560af9a7d72001e8852675f --- /dev/null +++ b/agentic/architecture/ai-native-generator-critic-architecture/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "ai-native-generator-critic-architecture", + "workflow_id": "ai-native-generator-critic-architecture", + "title": "AI-Native Generator-Critic Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "num_nodes": 9, + "num_lanes": 3, + "tags": [ + "ai-native", + "generator-critic", + "agentic-ai", + "tournament-mode", + "multi-agent", + "architecture-diagram" + ], + "description": "A competitive / generator-critic architecture where multiple generators produce independent answers, then an evaluator agent scores and selects the best output. This approach improves quality and reduces single-model brittleness. It's costlier (multiple LLM calls) but pays off when correctness or creativity matters more than latency.", + "source_path": "", + "repo_path": "agentic/architecture/ai-native-generator-critic-architecture" +} diff --git a/agentic/architecture/ai-native-generator-critic-architecture/workflow.fz b/agentic/architecture/ai-native-generator-critic-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..bdb3c9f1404d36a927a741f96d6aa066b98fb952 --- /dev/null +++ b/agentic/architecture/ai-native-generator-critic-architecture/workflow.fz @@ -0,0 +1,27 @@ +Input { # Input +n1: circle label:"Start" +n2: rectangle label:"Creative brief submitted" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Generators.n3.handle(top) [label="Brief"] +n2.handle(bottom) -> Generators.n4.handle(top) [label="Brief"] +n2.handle(bottom) -> Generators.n5.handle(top) [label="Brief"] +} +Generators { # Generator Agents +n3: rectangle label:"Agent A: Draft option 1" +n4: rectangle label:"Agent B: Draft option 2" +n5: rectangle label:"Agent C: Draft option 3" +n3.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 1"] +n4.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 2"] +n5.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 3"] +} +Evaluator { # Evaluator Agent +n6: rectangle label:"Score all options" +n7: diamond label:"Quality threshold met?" +n8: rectangle label:"Select best output" +n9: circle label:"Done" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(top) -> Generators.n3.handle(bottom) [label="No - Refine"] +n8.handle(right) -> n9.handle(left) +loop [refine until quality threshold met] n3 n4 n5 n6 n7 +} diff --git a/agentic/architecture/ai-native-hierarchical-architecture/README.md b/agentic/architecture/ai-native-hierarchical-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f4bc939a37d6bfdba3589ada8dfe1ee4274e9c36 --- /dev/null +++ b/agentic/architecture/ai-native-hierarchical-architecture/README.md @@ -0,0 +1,19 @@ +# AI-Native Hierarchical Architecture + +A hierarchical multi-agent architecture that scales orchestration by stacking supervisors and team leads (a tree structure), which mirrors enterprise org structures and helps partition context. This is the 'enterprise-grade agentic AI architecture' when a single orchestrator cannot manage all workers directly. Ideal for large enterprises and multi-domain workflows. + +**Template ID:** `ai-native-hierarchical-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration +**Complexity:** 4/5 +**Nodes:** 16 +**Lanes:** 4 +**Tags:** [ai-native, hierarchical, agentic-ai, enterprise, multi-agent, architecture-diagram] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-native-hierarchical-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-native-hierarchical-architecture/metadata.json b/agentic/architecture/ai-native-hierarchical-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..842758e23fb416b7a034d6d59ec176b389b7a9fc --- /dev/null +++ b/agentic/architecture/ai-native-hierarchical-architecture/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "ai-native-hierarchical-architecture", + "workflow_id": "ai-native-hierarchical-architecture", + "title": "AI-Native Hierarchical Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 16, + "num_lanes": 4, + "tags": [ + "ai-native", + "hierarchical", + "agentic-ai", + "enterprise", + "multi-agent", + "architecture-diagram" + ], + "description": "A hierarchical multi-agent architecture that scales orchestration by stacking supervisors and team leads (a tree structure), which mirrors enterprise org structures and helps partition context. This is the 'enterprise-grade agentic AI architecture' when a single orchestrator cannot manage all workers directly. Ideal for large enterprises and multi-domain workflows.", + "source_path": "", + "repo_path": "agentic/architecture/ai-native-hierarchical-architecture" +} diff --git a/agentic/architecture/ai-native-hierarchical-architecture/workflow.fz b/agentic/architecture/ai-native-hierarchical-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..4b0716d2838c6aeb15640bc306aef411b093d276 --- /dev/null +++ b/agentic/architecture/ai-native-hierarchical-architecture/workflow.fz @@ -0,0 +1,45 @@ +User { # User +n1: circle label:"Start" +n2: rectangle label:"Submit enterprise request" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Supervisor.n3.handle(top) [label="Goal"] +} +Supervisor { # Top-Level Supervisor +n3: rectangle label:"Decompose goal" +n4: rectangle label:"Delegate to team leads" +n5: rectangle label:"Aggregate final output" +n6: circle label:"Done" +n3.handle(right) -> n4.handle(left) +n4.handle(bottom) -> LeadA.n7.handle(top) [label="Sub-goal A"] +n4.handle(bottom) -> LeadB.n10.handle(top) [label="Sub-goal B"] +n5.handle(right) -> n6.handle(left) +n5.handle(top) -> User.n2.handle(bottom) [label="Final report"] +} +LeadA { # Team Lead A +n7: rectangle label:"Plan subtasks for A" +n8: rectangle label:"Dispatch to workers" +n9: rectangle label:"Consolidate A results" +n7.handle(right) -> n8.handle(left) +n8.handle(bottom) -> Workers.n13.handle(top) [label="Task A1"] +n8.handle(bottom) -> Workers.n14.handle(top) [label="Task A2"] +n9.handle(top) -> Supervisor.n5.handle(bottom) [label="Result A"] +} +LeadB { # Team Lead B +n10: rectangle label:"Plan subtasks for B" +n11: rectangle label:"Dispatch to workers" +n12: rectangle label:"Consolidate B results" +n10.handle(right) -> n11.handle(left) +n11.handle(bottom) -> Workers.n15.handle(top) [label="Task B1"] +n11.handle(bottom) -> Workers.n16.handle(top) [label="Task B2"] +n12.handle(top) -> Supervisor.n5.handle(bottom) [label="Result B"] +} +Workers { # Worker Agents +n13: rectangle label:"Worker A1 executes" +n14: rectangle label:"Worker A2 executes" +n15: rectangle label:"Worker B1 executes" +n16: rectangle label:"Worker B2 executes" +n13.handle(top) -> LeadA.n9.handle(bottom) [label="A1 done"] +n14.handle(top) -> LeadA.n9.handle(bottom) [label="A2 done"] +n15.handle(top) -> LeadB.n12.handle(bottom) [label="B1 done"] +n16.handle(top) -> LeadB.n12.handle(bottom) [label="B2 done"] +} diff --git a/agentic/architecture/ai-native-orchestrator-worker-architecture/README.md b/agentic/architecture/ai-native-orchestrator-worker-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0b19c3ab1361c575784e6d32567ee282b110f4ae --- /dev/null +++ b/agentic/architecture/ai-native-orchestrator-worker-architecture/README.md @@ -0,0 +1,19 @@ +# AI-Native Orchestrator-Worker Architecture + +An orchestrator-worker architecture where an orchestrator agent breaks a goal into subtasks, dispatches to specialized workers, then synthesizes a final response. This is the most common 'agent orchestration' architecture—powerful but the orchestrator can become a bottleneck as the number of workers grows. Frameworks like LangGraph focus on explicit routing/state to manage this. + +**Template ID:** `ai-native-orchestrator-worker-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration +**Complexity:** 3/5 +**Nodes:** 14 +**Lanes:** 4 +**Tags:** [ai-native, orchestrator-worker, agentic-ai, langgraph, multi-agent, architecture-diagram] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-native-orchestrator-worker-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-native-orchestrator-worker-architecture/metadata.json b/agentic/architecture/ai-native-orchestrator-worker-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..1b3cc684c78580eedba6332c1793b99751101053 --- /dev/null +++ b/agentic/architecture/ai-native-orchestrator-worker-architecture/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "ai-native-orchestrator-worker-architecture", + "workflow_id": "ai-native-orchestrator-worker-architecture", + "title": "AI-Native Orchestrator-Worker Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "num_nodes": 14, + "num_lanes": 4, + "tags": [ + "ai-native", + "orchestrator-worker", + "agentic-ai", + "langgraph", + "multi-agent", + "architecture-diagram" + ], + "description": "An orchestrator-worker architecture where an orchestrator agent breaks a goal into subtasks, dispatches to specialized workers, then synthesizes a final response. This is the most common 'agent orchestration' architecture—powerful but the orchestrator can become a bottleneck as the number of workers grows. Frameworks like LangGraph focus on explicit routing/state to manage this.", + "source_path": "", + "repo_path": "agentic/architecture/ai-native-orchestrator-worker-architecture" +} diff --git a/agentic/architecture/ai-native-orchestrator-worker-architecture/workflow.fz b/agentic/architecture/ai-native-orchestrator-worker-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0e10a7999086b098955b7f89cbb7d10ee21b9298 --- /dev/null +++ b/agentic/architecture/ai-native-orchestrator-worker-architecture/workflow.fz @@ -0,0 +1,40 @@ +User { # User +n1: circle label:"Start" +n2: rectangle label:"Submit complex task" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Orchestrator.n3.handle(top) [label="Task"] +} +Orchestrator { # Orchestrator Agent +n3: rectangle label:"Receive task" +n4: rectangle label:"Break into subtasks" +n5: rectangle label:"Dispatch subtasks" +n6: rectangle label:"Collect results" +n7: rectangle label:"Synthesize final answer" +n8: circle label:"Done" +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) +n5.handle(bottom) -> Research.n9.handle(top) [label="Research subtask"] +n5.handle(bottom) -> Code.n11.handle(top) [label="Code subtask"] +n5.handle(bottom) -> Review.n13.handle(top) [label="Review subtask"] +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n7.handle(top) -> User.n2.handle(bottom) [label="Response"] +} +Research { # Research Agent +n9: rectangle label:"Search sources" +n10: rectangle label:"Summarize findings" +n9.handle(right) -> n10.handle(left) +n10.handle(top) -> Orchestrator.n6.handle(bottom) [label="Research result"] +} +Code { # Code Agent +n11: rectangle label:"Generate code" +n12: rectangle label:"Run tests" +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> Orchestrator.n6.handle(bottom) [label="Code result"] +} +Review { # Review Agent +n13: rectangle label:"Evaluate quality" +n14: rectangle label:"Flag issues" +n13.handle(right) -> n14.handle(left) +n14.handle(top) -> Orchestrator.n6.handle(bottom) [label="Review result"] +} diff --git a/agentic/architecture/ai-native-single-agent-architecture/README.md b/agentic/architecture/ai-native-single-agent-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..18f82d346f323c5aecc622f26feb13c2215f1a2e --- /dev/null +++ b/agentic/architecture/ai-native-single-agent-architecture/README.md @@ -0,0 +1,19 @@ +# AI-Native Single Agent Architecture + +A single-agent AI architecture where one agent handles everything: parsing requests, reasoning, calling tools via MCP, and generating responses. This is the default architecture for prototypes and simple automations—easy to debug but hits context-window limits quickly and is hard to parallelize. Ideal for MVPs and solo builders shipping fast. + +**Template ID:** `ai-native-single-agent-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration, mcp +**Complexity:** 2/5 +**Nodes:** 11 +**Lanes:** 3 +**Tags:** [ai-native, single-agent, agentic-ai, mcp, architecture-diagram] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-native-single-agent-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-native-single-agent-architecture/metadata.json b/agentic/architecture/ai-native-single-agent-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8d891a175096e04c5fb2918027abf7c5024f9a0d --- /dev/null +++ b/agentic/architecture/ai-native-single-agent-architecture/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "ai-native-single-agent-architecture", + "workflow_id": "ai-native-single-agent-architecture", + "title": "AI-Native Single Agent Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration", + "mcp" + ], + "use_cases": [ + "agentic", + "ai-orchestration", + "mcp" + ], + "complexity": 2, + "num_nodes": 11, + "num_lanes": 3, + "tags": [ + "ai-native", + "single-agent", + "agentic-ai", + "mcp", + "architecture-diagram" + ], + "description": "A single-agent AI architecture where one agent handles everything: parsing requests, reasoning, calling tools via MCP, and generating responses. This is the default architecture for prototypes and simple automations—easy to debug but hits context-window limits quickly and is hard to parallelize. Ideal for MVPs and solo builders shipping fast.", + "source_path": "", + "repo_path": "agentic/architecture/ai-native-single-agent-architecture" +} diff --git a/agentic/architecture/ai-native-single-agent-architecture/workflow.fz b/agentic/architecture/ai-native-single-agent-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3503d785f25e6a109fc4c3d2c39c338062bf832d --- /dev/null +++ b/agentic/architecture/ai-native-single-agent-architecture/workflow.fz @@ -0,0 +1,29 @@ +User { # User +n1: circle label:"Start" +n2: rectangle label:"Send request" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Agent.n3.handle(top) [label="Request"] +} +Agent { # Single AI Agent +n3: rectangle label:"Receive input" +n4: rectangle label:"Reason and plan" +n5: rectangle label:"Decide tool call" +n6: rectangle label:"Process tool result" +n7: rectangle label:"Generate response" +n8: circle label:"Done" +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) +n5.handle(bottom) -> Tools.n9.handle(top) [label="MCP request"] +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n7.handle(top) -> User.n2.handle(bottom) [label="Response"] +loop [retry until goal met] n4 n5 n6 n7 +} +Tools { # Tool Server (MCP) +n9: rectangle label:"Receive MCP call" +n10: rectangle label:"Execute tool" +n11: rectangle label:"Return result" +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(top) -> Agent.n6.handle(bottom) [label="Tool result"] +} diff --git a/agentic/architecture/ai-orchestration-competitive-generator-critic/README.md b/agentic/architecture/ai-orchestration-competitive-generator-critic/README.md new file mode 100644 index 0000000000000000000000000000000000000000..452a36e0a8ff6d543b2735146a69199705f55a53 --- /dev/null +++ b/agentic/architecture/ai-orchestration-competitive-generator-critic/README.md @@ -0,0 +1,19 @@ +# AI Orchestration - Competitive Generator-Critic + +A tournament-mode architecture where multiple generator agents produce independent outputs in parallel, then an evaluator agent scores and selects the best. Quality threshold checking with refinement loops. Best when correctness or creativity matters more than latency. + +**Template ID:** `ai-orchestration-competitive-generator-critic` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [ai-native, competitive, generator-critic, tournament, multi-agent, architecture-diagram, orchestration] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-orchestration-competitive-generator-critic` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-orchestration-competitive-generator-critic/metadata.json b/agentic/architecture/ai-orchestration-competitive-generator-critic/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8b98cea1dda9b758144a143751365eeb7918db6d --- /dev/null +++ b/agentic/architecture/ai-orchestration-competitive-generator-critic/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "ai-orchestration-competitive-generator-critic", + "workflow_id": "ai-orchestration-competitive-generator-critic", + "title": "AI Orchestration - Competitive Generator-Critic", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "ai-native", + "competitive", + "generator-critic", + "tournament", + "multi-agent", + "architecture-diagram", + "orchestration" + ], + "description": "A tournament-mode architecture where multiple generator agents produce independent outputs in parallel, then an evaluator agent scores and selects the best. Quality threshold checking with refinement loops. Best when correctness or creativity matters more than latency.", + "source_path": "", + "repo_path": "agentic/architecture/ai-orchestration-competitive-generator-critic" +} diff --git a/agentic/architecture/ai-orchestration-competitive-generator-critic/workflow.fz b/agentic/architecture/ai-orchestration-competitive-generator-critic/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..1ca4d293e193ca12f50f3825195464e2a23742fd --- /dev/null +++ b/agentic/architecture/ai-orchestration-competitive-generator-critic/workflow.fz @@ -0,0 +1,29 @@ +Input { # Input + n1: circle label="Start" + n2: rectangle label="Creative brief submitted" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Generators.n3.handle(top) [label="Brief"] + n2.handle(bottom) -> Generators.n4.handle(top) [label="Brief"] + n2.handle(bottom) -> Generators.n5.handle(top) [label="Brief"] +} + +Generators { # Generator Agents + n3: rectangle label="Agent A: Draft option 1" + n4: rectangle label="Agent B: Draft option 2" + n5: rectangle label="Agent C: Draft option 3" + n3.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 1"] + n4.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 2"] + n5.handle(bottom) -> Evaluator.n6.handle(top) [label="Option 3"] +} + +Evaluator { # Evaluator Agent + n6: rectangle label="Score all options" + n7: diamond label="Quality threshold met?" + n8: rectangle label="Select best output" + n9: circle label="Done" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) [label="Yes"] + n7.handle(top) -> Generators.n3.handle(bottom) [label="No - Refine"] + n8.handle(right) -> n9.handle(left) + loop [refine until quality threshold met] n3 n4 n5 n6 n7 +} diff --git a/agentic/architecture/ai-orchestration-hierarchical/README.md b/agentic/architecture/ai-orchestration-hierarchical/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ce0d88dee3db39406e8e8f6a02800d907fcb2445 --- /dev/null +++ b/agentic/architecture/ai-orchestration-hierarchical/README.md @@ -0,0 +1,19 @@ +# AI Orchestration - Hierarchical (Org Chart) + +An org-chart architecture with multi-level structure. A top-level supervisor manages team leads, who each manage their own pool of specialist workers. Teams within teams. Best for enterprise-scale automation with 10+ specialized agents spanning multiple domains. + +**Template ID:** `ai-orchestration-hierarchical` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 5 +**Tags:** [ai-native, hierarchical, org-chart, enterprise, multi-agent, architecture-diagram, orchestration] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-orchestration-hierarchical` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-orchestration-hierarchical/metadata.json b/agentic/architecture/ai-orchestration-hierarchical/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d423aab063d31dfef303ca707fd44fbe04b64493 --- /dev/null +++ b/agentic/architecture/ai-orchestration-hierarchical/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "ai-orchestration-hierarchical", + "workflow_id": "ai-orchestration-hierarchical", + "title": "AI Orchestration - Hierarchical (Org Chart)", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 5, + "tags": [ + "ai-native", + "hierarchical", + "org-chart", + "enterprise", + "multi-agent", + "architecture-diagram", + "orchestration" + ], + "description": "An org-chart architecture with multi-level structure. A top-level supervisor manages team leads, who each manage their own pool of specialist workers. Teams within teams. Best for enterprise-scale automation with 10+ specialized agents spanning multiple domains.", + "source_path": "", + "repo_path": "agentic/architecture/ai-orchestration-hierarchical" +} diff --git a/agentic/architecture/ai-orchestration-hierarchical/workflow.fz b/agentic/architecture/ai-orchestration-hierarchical/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ad5cdff0c88a101192269363fadfe73d7365584b --- /dev/null +++ b/agentic/architecture/ai-orchestration-hierarchical/workflow.fz @@ -0,0 +1,49 @@ +User { # User + n1: circle label="Start" + n2: rectangle label="Submit enterprise request" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Supervisor.n3.handle(top) [label="Goal"] +} + +Supervisor { # Top-Level Supervisor + n3: rectangle label="Decompose goal" + n4: rectangle label="Delegate to team leads" + n5: rectangle label="Aggregate final output" + n6: circle label="Done" + n3.handle(right) -> n4.handle(left) + n4.handle(bottom) -> LeadA.n7.handle(top) [label="Sub-goal A"] + n4.handle(bottom) -> LeadB.n10.handle(top) [label="Sub-goal B"] + n5.handle(right) -> n6.handle(left) + n5.handle(top) -> User.n2.handle(bottom) [label="Final report"] +} + +LeadA { # Team Lead A + n7: rectangle label="Plan subtasks for A" + n8: rectangle label="Dispatch to workers" + n9: rectangle label="Consolidate A results" + n7.handle(right) -> n8.handle(left) + n8.handle(bottom) -> Workers.n13.handle(top) [label="Task A1"] + n8.handle(bottom) -> Workers.n14.handle(top) [label="Task A2"] + n9.handle(top) -> Supervisor.n5.handle(bottom) [label="Result A"] +} + +LeadB { # Team Lead B + n10: rectangle label="Plan subtasks for B" + n11: rectangle label="Dispatch to workers" + n12: rectangle label="Consolidate B results" + n10.handle(right) -> n11.handle(left) + n11.handle(bottom) -> Workers.n15.handle(top) [label="Task B1"] + n11.handle(bottom) -> Workers.n16.handle(top) [label="Task B2"] + n12.handle(top) -> Supervisor.n5.handle(bottom) [label="Result B"] +} + +Workers { # Worker Agents + n13: rectangle label="Worker A1 executes" + n14: rectangle label="Worker A2 executes" + n15: rectangle label="Worker B1 executes" + n16: rectangle label="Worker B2 executes" + n13.handle(top) -> LeadA.n9.handle(bottom) [label="A1 done"] + n14.handle(top) -> LeadA.n9.handle(bottom) [label="A2 done"] + n15.handle(top) -> LeadB.n12.handle(bottom) [label="B1 done"] + n16.handle(top) -> LeadB.n12.handle(bottom) [label="B2 done"] +} diff --git a/agentic/architecture/ai-orchestration-orchestrator-worker/README.md b/agentic/architecture/ai-orchestration-orchestrator-worker/README.md new file mode 100644 index 0000000000000000000000000000000000000000..86ac838e67b0a4fed20fac06c63f239c9fda3b42 --- /dev/null +++ b/agentic/architecture/ai-orchestration-orchestrator-worker/README.md @@ -0,0 +1,19 @@ +# AI Orchestration - Orchestrator-Worker + +A conductor-style architecture where one orchestrator agent receives a complex task, breaks it into subtasks, dispatches each to specialist worker agents (research, code, review), collects results, and synthesizes the final answer. Best for complex multi-step tasks with dynamic decomposition. + +**Template ID:** `ai-orchestration-orchestrator-worker` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration +**Complexity:** 3/5 +**Nodes:** 15 +**Lanes:** 5 +**Tags:** [ai-native, orchestrator-worker, conductor, multi-agent, architecture-diagram, orchestration] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-orchestration-orchestrator-worker` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-orchestration-orchestrator-worker/metadata.json b/agentic/architecture/ai-orchestration-orchestrator-worker/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8e2d6de074235856ab8a2e58fecafb5562acf7df --- /dev/null +++ b/agentic/architecture/ai-orchestration-orchestrator-worker/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "ai-orchestration-orchestrator-worker", + "workflow_id": "ai-orchestration-orchestrator-worker", + "title": "AI Orchestration - Orchestrator-Worker", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "num_nodes": 15, + "num_lanes": 5, + "tags": [ + "ai-native", + "orchestrator-worker", + "conductor", + "multi-agent", + "architecture-diagram", + "orchestration" + ], + "description": "A conductor-style architecture where one orchestrator agent receives a complex task, breaks it into subtasks, dispatches each to specialist worker agents (research, code, review), collects results, and synthesizes the final answer. Best for complex multi-step tasks with dynamic decomposition.", + "source_path": "", + "repo_path": "agentic/architecture/ai-orchestration-orchestrator-worker" +} diff --git a/agentic/architecture/ai-orchestration-orchestrator-worker/workflow.fz b/agentic/architecture/ai-orchestration-orchestrator-worker/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0b9a88de0940a7fb5cf563745ae2dfca12678a1d --- /dev/null +++ b/agentic/architecture/ai-orchestration-orchestrator-worker/workflow.fz @@ -0,0 +1,44 @@ +User { # User + n1: circle label="Start" + n2: rectangle label="Submit complex task" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Orchestrator.n3.handle(top) [label="Task"] +} + +Orchestrator { # Orchestrator Agent + n3: rectangle label="Receive task" + n4: rectangle label="Break into subtasks" + n5: rectangle label="Dispatch subtasks" + n6: rectangle label="Collect results" + n7: rectangle label="Synthesize final answer" + n8: circle label="Done" + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> n5.handle(left) + n5.handle(bottom) -> Research.n9.handle(top) [label="Research subtask"] + n5.handle(bottom) -> Code.n11.handle(top) [label="Code subtask"] + n5.handle(bottom) -> Review.n13.handle(top) [label="Review subtask"] + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n7.handle(top) -> User.n2.handle(bottom) [label="Response"] +} + +Research { # Research Agent + n9: rectangle label="Search sources" + n10: rectangle label="Summarize findings" + n9.handle(right) -> n10.handle(left) + n10.handle(top) -> Orchestrator.n6.handle(bottom) [label="Research result"] +} + +Code { # Code Agent + n11: rectangle label="Generate code" + n12: rectangle label="Run tests" + n11.handle(right) -> n12.handle(left) + n12.handle(top) -> Orchestrator.n6.handle(bottom) [label="Code result"] +} + +Review { # Review Agent + n13: rectangle label="Evaluate quality" + n14: rectangle label="Flag issues" + n13.handle(right) -> n14.handle(left) + n14.handle(top) -> Orchestrator.n6.handle(bottom) [label="Review result"] +} diff --git a/agentic/architecture/ai-orchestration-parallel-fan-out/README.md b/agentic/architecture/ai-orchestration-parallel-fan-out/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d3740fd230dedd3d3d81d87b34e8389e4dabd41e --- /dev/null +++ b/agentic/architecture/ai-orchestration-parallel-fan-out/README.md @@ -0,0 +1,19 @@ +# AI Orchestration - Parallel Fan-Out (Map-Reduce) + +A map-reduce style architecture where a coordinator fans out tasks to multiple parallel worker agents (style check, security audit, performance analysis), gathers all results, and makes an aggregate decision. Best for PR reviews, code reviews, and multi-dimensional analysis. + +**Template ID:** `ai-orchestration-parallel-fan-out` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** ai-orchestration +**Complexity:** 3/5 +**Nodes:** 9 +**Lanes:** 3 +**Tags:** [ai-native, parallel-fan-out, map-reduce, coordinator, multi-agent, architecture-diagram, orchestration] +**Source path:** `` +**Repo path:** `agentic/architecture/ai-orchestration-parallel-fan-out` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/ai-orchestration-parallel-fan-out/metadata.json b/agentic/architecture/ai-orchestration-parallel-fan-out/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bfb4fb4f4c02450b9cac3121555203760622d953 --- /dev/null +++ b/agentic/architecture/ai-orchestration-parallel-fan-out/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "ai-orchestration-parallel-fan-out", + "workflow_id": "ai-orchestration-parallel-fan-out", + "title": "AI Orchestration - Parallel Fan-Out (Map-Reduce)", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "num_nodes": 9, + "num_lanes": 3, + "tags": [ + "ai-native", + "parallel-fan-out", + "map-reduce", + "coordinator", + "multi-agent", + "architecture-diagram", + "orchestration" + ], + "description": "A map-reduce style architecture where a coordinator fans out tasks to multiple parallel worker agents (style check, security audit, performance analysis), gathers all results, and makes an aggregate decision. Best for PR reviews, code reviews, and multi-dimensional analysis.", + "source_path": "", + "repo_path": "agentic/architecture/ai-orchestration-parallel-fan-out" +} diff --git a/agentic/architecture/ai-orchestration-parallel-fan-out/workflow.fz b/agentic/architecture/ai-orchestration-parallel-fan-out/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0770ad69b43c99edb2f765354cfb40337a56e427 --- /dev/null +++ b/agentic/architecture/ai-orchestration-parallel-fan-out/workflow.fz @@ -0,0 +1,31 @@ +Trigger { # Trigger + n1: circle label="Start" + n2: rectangle label="PR submitted for review" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Coordinator.n3.handle(top) [label="PR payload"] +} + +Coordinator { # Coordinator Agent + n3: rectangle label="Fan out to reviewers" + n4: rectangle label="Gather all reviews" + n5: diamond label="All passed?" + n6: rectangle label="Approve PR" + n7: rectangle label="Request changes" + n8: circle label="Done" + n3.handle(bottom) -> Reviewers.n9.handle(top) [label="Style check"] + n3.handle(bottom) -> Reviewers.n10.handle(top) [label="Security audit"] + n3.handle(bottom) -> Reviewers.n11.handle(top) [label="Perf analysis"] + n4.handle(right) -> n5.handle(left) + n5.handle(right) -> n6.handle(left) [label="Yes"] + n5.handle(bottom) -> n7.handle(top) [label="No"] + n6.handle(right) -> n8.handle(left) +} + +Reviewers { # Parallel Review Agents + n9: rectangle label="Style Agent" + n10: rectangle label="Security Agent" + n11: rectangle label="Performance Agent" + n9.handle(top) -> Coordinator.n4.handle(bottom) [label="Style report"] + n10.handle(top) -> Coordinator.n4.handle(bottom) [label="Security report"] + n11.handle(top) -> Coordinator.n4.handle(bottom) [label="Perf report"] +} diff --git a/agentic/architecture/context-shared-memory/README.md b/agentic/architecture/context-shared-memory/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b0ae3f7203ee79af19ab86813324d4c0ba55eee6 --- /dev/null +++ b/agentic/architecture/context-shared-memory/README.md @@ -0,0 +1,19 @@ +# Context Management - Shared Memory + +Multi-agent coordination pattern where an orchestrator breaks work into subtasks, specialist agents pull from and push to a shared state store, and the orchestrator composes the final answer from that shared state. Multi-agent setups feel coherent instead of each assistant having its own inconsistent memory. + +**Template ID:** `context-shared-memory` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** agentic +**Secondary use cases:** context-management +**Complexity:** 3/5 +**Nodes:** 9 +**Lanes:** 4 +**Tags:** [context-management, shared-memory, multi-agent, orchestrator, architecture-diagram] +**Source path:** `` +**Repo path:** `agentic/architecture/context-shared-memory` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/architecture/context-shared-memory/metadata.json b/agentic/architecture/context-shared-memory/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..031223d6b57c98e56cdd98e42dd184e1c13162e5 --- /dev/null +++ b/agentic/architecture/context-shared-memory/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "context-shared-memory", + "workflow_id": "context-shared-memory", + "title": "Context Management - Shared Memory", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "context-management" + ], + "use_cases": [ + "agentic", + "context-management" + ], + "complexity": 3, + "num_nodes": 9, + "num_lanes": 4, + "tags": [ + "context-management", + "shared-memory", + "multi-agent", + "orchestrator", + "architecture-diagram" + ], + "description": "Multi-agent coordination pattern where an orchestrator breaks work into subtasks, specialist agents pull from and push to a shared state store, and the orchestrator composes the final answer from that shared state. Multi-agent setups feel coherent instead of each assistant having its own inconsistent memory.", + "source_path": "", + "repo_path": "agentic/architecture/context-shared-memory" +} diff --git a/agentic/architecture/context-shared-memory/workflow.fz b/agentic/architecture/context-shared-memory/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..7977a28ad7046abfd0ca984b631a213bb1390992 --- /dev/null +++ b/agentic/architecture/context-shared-memory/workflow.fz @@ -0,0 +1,46 @@ +Orchestrator { + n1: circle label="Complex task arrives" + n2: rectangle label="Request shared context" + n3: rectangle label="Create research subtask" + n4: rectangle label="Create action subtask" + n5: rectangle label="Receive findings and results" + n6: rectangle label="Compile final answer" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> SharedMemory.n7.handle(top) [label="Read state"] + n3.handle(right) -> n4.handle(left) + n3.handle(bottom) -> Researcher.n9.handle(top) [label="Research task"] + n4.handle(bottom) -> Operator.n13.handle(top) [label="Action task"] + n5.handle(right) -> n6.handle(left) + Researcher.n12.handle(top) -> n5.handle(left) [label="Finding"] + Operator.n17.handle(top) -> n5.handle(right) [label="Result"] +} + +Researcher { + n9: rectangle label="Receive research task" + n10: rectangle label="Read shared memory" + n11: rectangle label="Analyze with context" + n12: rectangle label="Return finding" + n9.handle(right) -> n10.handle(left) + n10.handle(right) -> n11.handle(left) + n11.handle(right) -> n12.handle(left) + n10.handle(bottom) -> SharedMemory.n7.handle(left) [label="Read state"] +} + +Operator { + n13: rectangle label="Receive action task" + n14: rectangle label="Read shared memory" + n15: rectangle label="Execute with context" + n16: rectangle label="Write result to memory" + n17: rectangle label="Return result" + n13.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> n16.handle(left) + n16.handle(bottom) -> SharedMemory.n8.handle(left) [label="Write state"] + n15.handle(bottom) -> n17.handle(top) +} + +SharedMemory { + n7: rectangle label="Resolve memory request" + n8: rectangle label="Update shared state" + n7.handle(right) -> n8.handle(left) +} diff --git a/agentic/devops/mcp-agent-mesh/README.md b/agentic/devops/mcp-agent-mesh/README.md new file mode 100644 index 0000000000000000000000000000000000000000..36fa554fa25e6537e48413fc21d11e11b4fb2548 --- /dev/null +++ b/agentic/devops/mcp-agent-mesh/README.md @@ -0,0 +1,19 @@ +# MCP Agent Mesh Architecture + +A multi-agent mesh pattern where agents communicate through a shared context broker backed by MCP. Enables coordinated tool access and state synchronization across multiple specialized agents (planner, coder, reviewer, operator). Supports both orchestrated and choreographed interaction patterns. + +**Template ID:** `mcp-agent-mesh` +**Kind:** architecture +**Source domain:** DevOps +**Primary use case:** agentic +**Secondary use cases:** mcp +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 4 +**Tags:** [mcp, agent-mesh, shared-context, multi-agent, broker, architecture-diagram, production-grade] +**Source path:** `` +**Repo path:** `agentic/devops/mcp-agent-mesh` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/agentic/devops/mcp-agent-mesh/metadata.json b/agentic/devops/mcp-agent-mesh/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..41a1f680202d66fabd3f1662a89597803bc19d27 --- /dev/null +++ b/agentic/devops/mcp-agent-mesh/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "mcp-agent-mesh", + "workflow_id": "mcp-agent-mesh", + "title": "MCP Agent Mesh Architecture", + "kind": "architecture", + "source_domain": "DevOps", + "primary_use_case": "agentic", + "secondary_use_cases": [ + "mcp" + ], + "use_cases": [ + "agentic", + "mcp" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 4, + "tags": [ + "mcp", + "agent-mesh", + "shared-context", + "multi-agent", + "broker", + "architecture-diagram", + "production-grade" + ], + "description": "A multi-agent mesh pattern where agents communicate through a shared context broker backed by MCP. Enables coordinated tool access and state synchronization across multiple specialized agents (planner, coder, reviewer, operator). Supports both orchestrated and choreographed interaction patterns.", + "source_path": "", + "repo_path": "agentic/devops/mcp-agent-mesh" +} diff --git a/agentic/devops/mcp-agent-mesh/workflow.fz b/agentic/devops/mcp-agent-mesh/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..7966f82abd5fa9b4c79f77a278a5f270c29f5f57 --- /dev/null +++ b/agentic/devops/mcp-agent-mesh/workflow.fz @@ -0,0 +1,41 @@ +Orchestrator { # Orchestrator Agent + n1: circle label="Complex task received" + n2: rectangle label="Decompose into subtasks" + n3: rectangle label="Assign subtask to Agent B" + n4: rectangle label="Receive subtask result" + n5: rectangle label="Request shared context" + n6: rectangle label="Compile final response" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> Worker.n7.handle(top) [label="Subtask assignment"] + n4.handle(right) -> n5.handle(left) + n5.handle(bottom) -> Broker.n11.handle(top) [label="Context request"] + n6.handle(left) -> n2.handle(bottom) [label="Next iteration"] +} + +Worker { # Worker Agent + n7: rectangle label="Receive subtask" + n8: rectangle label="Fetch shared context" + n9: rectangle label="Call MCP tool" + n10: rectangle label="Return result to orchestrator" + n7.handle(right) -> n8.handle(left) + n8.handle(bottom) -> Broker.n11.handle(left) [label="Context request"] + n8.handle(right) -> n9.handle(left) + n9.handle(bottom) -> MCPServer.n13.handle(top) [label="MCP tool call"] + n10.handle(top) -> Orchestrator.n4.handle(bottom) [label="Subtask result"] +} + +Broker { # Shared Context Broker + n11: rectangle label="Resolve context request" + n12: rectangle label="Return shared state" + n11.handle(right) -> n12.handle(left) + n12.handle(top) -> Orchestrator.n6.handle(bottom) [label="Context to orchestrator"] + n12.handle(left) -> Worker.n9.handle(top) [label="Context to worker"] +} + +MCPServer { # MCP Server + n13: rectangle label="Execute tool" + n14: rectangle label="Return tool output" + n13.handle(right) -> n14.handle(left) + n14.handle(top) -> Worker.n10.handle(bottom) [label="Tool output"] +} diff --git a/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/README.md b/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1a78b95d4ab97c500eedbca2a357363f55fe20c9 --- /dev/null +++ b/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/README.md @@ -0,0 +1,19 @@ +# AI Orchestration - Event-Driven Mesh (Kafka-First) + +An event-driven agent mesh architecture using a Kafka-style event broker. Multiple agents subscribe to topics (orders, alerts, analytics), process events independently, and publish results back to the bus. Best for real-time event processing and decoupled service architectures. + +**Template ID:** `ai-orchestration-event-driven-mesh` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** ai-orchestration +**Secondary use cases:** mcp +**Complexity:** 3/5 +**Nodes:** 13 +**Lanes:** 5 +**Tags:** [ai-native, event-driven, kafka, agent-mesh, pub-sub, architecture-diagram, orchestration] +**Source path:** `` +**Repo path:** `ai-orchestration/architecture/ai-orchestration-event-driven-mesh` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/metadata.json b/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..2779e9e7e0fbf6751d295a264d57f79f9c1caa65 --- /dev/null +++ b/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "ai-orchestration-event-driven-mesh", + "workflow_id": "ai-orchestration-event-driven-mesh", + "title": "AI Orchestration - Event-Driven Mesh (Kafka-First)", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "ai-orchestration", + "secondary_use_cases": [ + "mcp" + ], + "use_cases": [ + "ai-orchestration", + "mcp" + ], + "complexity": 3, + "num_nodes": 13, + "num_lanes": 5, + "tags": [ + "ai-native", + "event-driven", + "kafka", + "agent-mesh", + "pub-sub", + "architecture-diagram", + "orchestration" + ], + "description": "An event-driven agent mesh architecture using a Kafka-style event broker. Multiple agents subscribe to topics (orders, alerts, analytics), process events independently, and publish results back to the bus. Best for real-time event processing and decoupled service architectures.", + "source_path": "", + "repo_path": "ai-orchestration/architecture/ai-orchestration-event-driven-mesh" +} diff --git a/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/workflow.fz b/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6f9f0335db5695006c7782b0c037a9b38657e46b --- /dev/null +++ b/ai-orchestration/architecture/ai-orchestration-event-driven-mesh/workflow.fz @@ -0,0 +1,39 @@ +Source { # Event Sources + n1: circle label="Start" + n2: rectangle label="User action event" + n3: rectangle label="System alert event" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Broker.n4.handle(top) [label="Publish event"] + n3.handle(bottom) -> Broker.n4.handle(top) [label="Publish event"] +} + +Broker { # Event Broker (Kafka / Pub-Sub) + n4: rectangle label="Event bus receives event" + n5: rectangle label="Route to subscribers" + n4.handle(right) -> n5.handle(left) + n5.handle(bottom) -> Orders.n6.handle(top) [label="topic: orders"] + n5.handle(bottom) -> Alerts.n8.handle(top) [label="topic: alerts"] + n5.handle(bottom) -> Analytics.n10.handle(top) [label="topic: analytics"] +} + +Orders { # Order Processing Agent + n6: rectangle label="Parse order event" + n7: rectangle label="Execute fulfillment" + n6.handle(right) -> n7.handle(left) + n7.handle(bottom) -> Broker.n4.handle(top) [label="Publish: order.completed"] +} + +Alerts { # Alert Triage Agent + n8: rectangle label="Classify severity" + n9: rectangle label="Route to on-call or auto-resolve" + n8.handle(right) -> n9.handle(left) + n9.handle(bottom) -> Broker.n4.handle(top) [label="Publish: alert.resolved"] +} + +Analytics { # Analytics Agent + n10: rectangle label="Aggregate metrics" + n11: rectangle label="Update dashboard" + n12: circle label="Stored" + n10.handle(right) -> n11.handle(left) + n11.handle(right) -> n12.handle(left) +} diff --git a/ai-orchestration/architecture/ai-orchestration-single-agent/README.md b/ai-orchestration/architecture/ai-orchestration-single-agent/README.md new file mode 100644 index 0000000000000000000000000000000000000000..12e3228eec060742d740c6c1abd7bfe4f40ddfe6 --- /dev/null +++ b/ai-orchestration/architecture/ai-orchestration-single-agent/README.md @@ -0,0 +1,19 @@ +# AI Orchestration - Single Agent (Monolith) + +The simplest AI-native architecture — a single agent that receives user input, reasons, plans, decides on tool calls, processes results, and generates responses. Direct MCP connection over stdio or HTTP. Best for MVPs and when low latency matters. + +**Template ID:** `ai-orchestration-single-agent` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** ai-orchestration +**Secondary use cases:** mcp +**Complexity:** 2/5 +**Nodes:** 12 +**Lanes:** 3 +**Tags:** [ai-native, single-agent, monolith, mcp, architecture-diagram, orchestration] +**Source path:** `` +**Repo path:** `ai-orchestration/architecture/ai-orchestration-single-agent` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/ai-orchestration/architecture/ai-orchestration-single-agent/metadata.json b/ai-orchestration/architecture/ai-orchestration-single-agent/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ee7de4bbd20cb9d2365e9980ab3f43fba281733b --- /dev/null +++ b/ai-orchestration/architecture/ai-orchestration-single-agent/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "ai-orchestration-single-agent", + "workflow_id": "ai-orchestration-single-agent", + "title": "AI Orchestration - Single Agent (Monolith)", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "ai-orchestration", + "secondary_use_cases": [ + "mcp" + ], + "use_cases": [ + "ai-orchestration", + "mcp" + ], + "complexity": 2, + "num_nodes": 12, + "num_lanes": 3, + "tags": [ + "ai-native", + "single-agent", + "monolith", + "mcp", + "architecture-diagram", + "orchestration" + ], + "description": "The simplest AI-native architecture — a single agent that receives user input, reasons, plans, decides on tool calls, processes results, and generates responses. Direct MCP connection over stdio or HTTP. Best for MVPs and when low latency matters.", + "source_path": "", + "repo_path": "ai-orchestration/architecture/ai-orchestration-single-agent" +} diff --git a/ai-orchestration/architecture/ai-orchestration-single-agent/workflow.fz b/ai-orchestration/architecture/ai-orchestration-single-agent/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..a21c98912bbdd484904b02b912d89a0bf474f014 --- /dev/null +++ b/ai-orchestration/architecture/ai-orchestration-single-agent/workflow.fz @@ -0,0 +1,31 @@ +User { # User + n1: circle label="Start" + n2: rectangle label="Send request" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Agent.n3.handle(top) [label="Request"] +} + +Agent { # Single AI Agent + n3: rectangle label="Receive input" + n4: rectangle label="Reason and plan" + n5: rectangle label="Decide tool call" + n6: rectangle label="Process tool result" + n7: rectangle label="Generate response" + n8: circle label="Done" + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> n5.handle(left) + n5.handle(bottom) -> Tools.n9.handle(top) [label="MCP request"] + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n7.handle(top) -> User.n2.handle(bottom) [label="Response"] + loop [retry until goal met] n4 n5 n6 n7 +} + +Tools { # Tool Server (MCP) + n9: rectangle label="Receive MCP call" + n10: rectangle label="Execute tool" + n11: rectangle label="Return result" + n9.handle(right) -> n10.handle(left) + n10.handle(right) -> n11.handle(left) + n11.handle(top) -> Agent.n6.handle(bottom) [label="Tool result"] +} diff --git a/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/README.md b/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..27fde0c1c03340c0fe1949f3a3e7faf5e2653b2b --- /dev/null +++ b/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/README.md @@ -0,0 +1,19 @@ +# Kubernetes Container Orchestration Architecture + +A Kubernetes container orchestration architecture diagram showing the control plane (API Server, etcd, Scheduler, Controller Manager), worker nodes (Kubelet, container runtime, kube-proxy, pods), networking layer (Ingress, Network Policy, Service Mesh), and persistent storage with CSI drivers. This template provides a comprehensive view of the Kubernetes architecture stack from control plane to storage layer. Foundational reference for DevOps engineers and platform teams managing Kubernetes clusters. + +**Template ID:** `kubernetes-container-orchestration-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** ai-orchestration +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [kubernetes, container-orchestration, k8s, control-plane, worker-node, ingress, persistent-storage, architecture-diagram] +**Source path:** `` +**Repo path:** `ai-orchestration/architecture/kubernetes-container-orchestration-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/metadata.json b/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..a2dba4312e763184c283677517daab9ed3f7383c --- /dev/null +++ b/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "kubernetes-container-orchestration-architecture", + "workflow_id": "kubernetes-container-orchestration-architecture", + "title": "Kubernetes Container Orchestration Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "ai-orchestration", + "secondary_use_cases": [], + "use_cases": [ + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "kubernetes", + "container-orchestration", + "k8s", + "control-plane", + "worker-node", + "ingress", + "persistent-storage", + "architecture-diagram" + ], + "description": "A Kubernetes container orchestration architecture diagram showing the control plane (API Server, etcd, Scheduler, Controller Manager), worker nodes (Kubelet, container runtime, kube-proxy, pods), networking layer (Ingress, Network Policy, Service Mesh), and persistent storage with CSI drivers. This template provides a comprehensive view of the Kubernetes architecture stack from control plane to storage layer. Foundational reference for DevOps engineers and platform teams managing Kubernetes clusters.", + "source_path": "", + "repo_path": "ai-orchestration/architecture/kubernetes-container-orchestration-architecture" +} diff --git a/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/workflow.fz b/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..1481ad2dee6d4e462468683e8fa581f536c73f75 --- /dev/null +++ b/ai-orchestration/architecture/kubernetes-container-orchestration-architecture/workflow.fz @@ -0,0 +1,41 @@ +ControlPlane { # Kubernetes Control Plane +n1: rectangle label:"API Server" +n2: rectangle label:"etcd (Cluster State)" +n3: rectangle label:"Scheduler" +n4: rectangle label:"Controller Manager" +n5: rectangle label:"Cloud Controller" +n1.handle(right) -> n2.handle(left) [label="Store State"] +n1.handle(bottom) -> n3.handle(top) [label="Schedule Pods"] +n3.handle(right) -> n4.handle(left) [label="Reconcile"] +n4.handle(right) -> n5.handle(left) [label="Cloud Resources"] +n3.handle(bottom) -> WorkerNode.n6.handle(top) [label="Assign Pod"] +} +WorkerNode { # Worker Node +n6: rectangle label:"Kubelet" +n7: rectangle label:"Container Runtime (containerd)" +n8: rectangle label:"kube-proxy" +n9: rectangle label:"Pod A (App Container)" +n10: rectangle label:"Pod B (App Container)" +n11: rectangle label:"Pod C (Sidecar + App)" +n6.handle(right) -> n7.handle(left) [label="Pull Image"] +n7.handle(right) -> n9.handle(left) [label="Start Container"] +n7.handle(bottom) -> n10.handle(top) [label="Start Container"] +n7.handle(bottom) -> n11.handle(top) [label="Start Container"] +n8.handle(bottom) -> Networking.n12.handle(top) [label="Service Routing"] +} +Networking { # Networking Layer +n12: rectangle label:"ClusterIP Service" +n13: rectangle label:"Ingress Controller" +n14: rectangle label:"Network Policy" +n15: rectangle label:"Service Mesh (Istio)" +n12.handle(right) -> n13.handle(left) [label="Expose"] +n13.handle(right) -> n14.handle(left) [label="Filter"] +n14.handle(right) -> n15.handle(left) [label="mTLS"] +} +Storage { # Persistent Storage +n16: rectangle label:"PersistentVolume" +n17: rectangle label:"StorageClass (SSD/HDD)" +n18: rectangle label:"CSI Driver" +n16.handle(right) -> n17.handle(left) [label="Provision"] +n17.handle(right) -> n18.handle(left) [label="Cloud Disk"] +} diff --git a/ai-orchestration/architecture/saga-distributed-transaction-architecture/README.md b/ai-orchestration/architecture/saga-distributed-transaction-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4b2da3ae430445c242306dd717908b09fe3287d1 --- /dev/null +++ b/ai-orchestration/architecture/saga-distributed-transaction-architecture/README.md @@ -0,0 +1,19 @@ +# Saga Distributed Transaction Architecture + +A distributed transaction architecture diagram implementing the two-phase commit protocol with a transaction coordinator sending prepare and commit messages to participating services, with global abort on any vote failure. This template visualizes the classic 2PC protocol used when strong consistency is required across multiple services, showing the prepare, vote, and commit/abort phases. Important for understanding distributed consensus trade-offs in microservices architectures. + +**Template ID:** `saga-distributed-transaction-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** ai-orchestration +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [distributed-transaction, two-phase-commit, 2pc, transaction-coordinator, consensus, strong-consistency, prepare-commit, architecture-diagram] +**Source path:** `` +**Repo path:** `ai-orchestration/architecture/saga-distributed-transaction-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/ai-orchestration/architecture/saga-distributed-transaction-architecture/metadata.json b/ai-orchestration/architecture/saga-distributed-transaction-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..37ebc8a40287132b174e181326f7a4b2624e89a4 --- /dev/null +++ b/ai-orchestration/architecture/saga-distributed-transaction-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "saga-distributed-transaction-architecture", + "workflow_id": "saga-distributed-transaction-architecture", + "title": "Saga Distributed Transaction Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "ai-orchestration", + "secondary_use_cases": [], + "use_cases": [ + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "distributed-transaction", + "two-phase-commit", + "2pc", + "transaction-coordinator", + "consensus", + "strong-consistency", + "prepare-commit", + "architecture-diagram" + ], + "description": "A distributed transaction architecture diagram implementing the two-phase commit protocol with a transaction coordinator sending prepare and commit messages to participating services, with global abort on any vote failure. This template visualizes the classic 2PC protocol used when strong consistency is required across multiple services, showing the prepare, vote, and commit/abort phases. Important for understanding distributed consensus trade-offs in microservices architectures.", + "source_path": "", + "repo_path": "ai-orchestration/architecture/saga-distributed-transaction-architecture" +} diff --git a/ai-orchestration/architecture/saga-distributed-transaction-architecture/workflow.fz b/ai-orchestration/architecture/saga-distributed-transaction-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6e44b251e9c54ee2030cda58ce5a4db282957ab1 --- /dev/null +++ b/ai-orchestration/architecture/saga-distributed-transaction-architecture/workflow.fz @@ -0,0 +1,49 @@ +Coordinator { # Transaction Coordinator +n1: circle label:"Begin Distributed Transaction" +n2: rectangle label:"Assign Transaction ID" +n3: rectangle label:"Send Prepare to All" +n16: rectangle label:"Collect Votes" +n17: diamond label:"All Voted Commit?" +n18: rectangle label:"Send Global Commit" +n19: rectangle label:"Send Global Abort" +n20: circle label:"Transaction Complete" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="TxID"] +n3.handle(bottom) -> ServiceA.n4.handle(top) [label="Prepare"] +n3.handle(bottom) -> ServiceB.n7.handle(top) [label="Prepare"] +n3.handle(bottom) -> ServiceC.n10.handle(top) [label="Prepare"] +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(right) -> n20.handle(left) +n19.handle(right) -> n20.handle(left) [label="Rolled Back"] +} +ServiceA { # Booking Service +n4: rectangle label:"Lock Resources" +n5: rectangle label:"Vote Commit" +n6: rectangle label:"Send Vote" +n4.handle(right) -> n5.handle(left) [label="Prepared"] +n5.handle(right) -> n6.handle(left) +n6.handle(top) -> Coordinator.n16.handle(bottom) [label="Vote"] +} +ServiceB { # Payment Service +n7: rectangle label:"Hold Funds" +n8: rectangle label:"Vote Commit" +n9: rectangle label:"Send Vote" +n7.handle(right) -> n8.handle(left) [label="Prepared"] +n8.handle(right) -> n9.handle(left) +n9.handle(top) -> Coordinator.n16.handle(bottom) [label="Vote"] +} +ServiceC { # Notification Service +n10: rectangle label:"Queue Notification" +n11: rectangle label:"Vote Commit" +n12: rectangle label:"Send Vote" +n13: rectangle label:"Apply Changes" +n14: rectangle label:"Capture Payment" +n15: rectangle label:"Send Notification" +n10.handle(right) -> n11.handle(left) [label="Prepared"] +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> Coordinator.n16.handle(bottom) [label="Vote"] +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +} diff --git a/ai-orchestration/architecture/saga-travel-booking-architecture/README.md b/ai-orchestration/architecture/saga-travel-booking-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b645dfe4209634f9f0d6471b58f02405cfd95f33 --- /dev/null +++ b/ai-orchestration/architecture/saga-travel-booking-architecture/README.md @@ -0,0 +1,19 @@ +# Saga Travel Booking Architecture + +A travel booking saga architecture diagram orchestrating flight, hotel, and car rental reservations as a single distributed transaction, with automatic compensation to cancel all bookings if any reservation step fails. This template models the classic saga use case where multiple independent services must either all succeed or all roll back, ensuring travelers never end up with partial bookings. Perfect for demonstrating saga patterns with a real-world business scenario. + +**Template ID:** `saga-travel-booking-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** ai-orchestration +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 5 +**Tags:** [saga-pattern, travel-booking, flight-reservation, hotel-booking, compensation, distributed-transaction, orchestration, architecture-diagram] +**Source path:** `` +**Repo path:** `ai-orchestration/architecture/saga-travel-booking-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/ai-orchestration/architecture/saga-travel-booking-architecture/metadata.json b/ai-orchestration/architecture/saga-travel-booking-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8bbe5c31e2a063836fcebd01015469e6c1c62c27 --- /dev/null +++ b/ai-orchestration/architecture/saga-travel-booking-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "saga-travel-booking-architecture", + "workflow_id": "saga-travel-booking-architecture", + "title": "Saga Travel Booking Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "ai-orchestration", + "secondary_use_cases": [], + "use_cases": [ + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 5, + "tags": [ + "saga-pattern", + "travel-booking", + "flight-reservation", + "hotel-booking", + "compensation", + "distributed-transaction", + "orchestration", + "architecture-diagram" + ], + "description": "A travel booking saga architecture diagram orchestrating flight, hotel, and car rental reservations as a single distributed transaction, with automatic compensation to cancel all bookings if any reservation step fails. This template models the classic saga use case where multiple independent services must either all succeed or all roll back, ensuring travelers never end up with partial bookings. Perfect for demonstrating saga patterns with a real-world business scenario.", + "source_path": "", + "repo_path": "ai-orchestration/architecture/saga-travel-booking-architecture" +} diff --git a/ai-orchestration/architecture/saga-travel-booking-architecture/workflow.fz b/ai-orchestration/architecture/saga-travel-booking-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..986677c05dbbd112486bfeae17d425f5886b3201 --- /dev/null +++ b/ai-orchestration/architecture/saga-travel-booking-architecture/workflow.fz @@ -0,0 +1,57 @@ +BookingAPI { # Booking API +n1: circle label:"Book Travel Package" +n2: rectangle label:"Validate Booking Request" +n3: rectangle label:"Start Booking Saga" +n24: rectangle label:"Return Booking Status" +n25: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Valid"] +n3.handle(bottom) -> Saga.n4.handle(top) [label="Execute"] +n24.handle(right) -> n25.handle(left) +} +Saga { # Saga Orchestrator +n4: rectangle label:"Step 1: Book Flight" +n9: rectangle label:"Step 2: Book Hotel" +n14: rectangle label:"Step 3: Book Car Rental" +n19: diamond label:"All Bookings OK?" +n20: rectangle label:"Confirm All Reservations" +n21: rectangle label:"Compensate Failed Steps" +n22: rectangle label:"Send Confirmed" +n23: rectangle label:"Send Cancelled" +n4.handle(bottom) -> FlightService.n5.handle(top) [label="Reserve"] +n9.handle(bottom) -> HotelService.n10.handle(top) [label="Reserve"] +n14.handle(bottom) -> CarService.n15.handle(top) [label="Reserve"] +n19.handle(right) -> n20.handle(left) [label="All Success"] +n19.handle(bottom) -> n21.handle(top) [label="Any Failed"] +n20.handle(right) -> n22.handle(left) +n21.handle(right) -> n23.handle(left) +n22.handle(top) -> BookingAPI.n24.handle(bottom) [label="Confirmed"] +n23.handle(top) -> BookingAPI.n24.handle(bottom) [label="Cancelled"] +} +FlightService { # Flight Service +n5: rectangle label:"Reserve Flight Seat" +n6: rectangle label:"Send Flight Result" +n7: rectangle label:"Forward Flight ID" +n8: rectangle label:"Cancel Flight (Compensate)" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(top) -> Saga.n9.handle(bottom) [label="Flight OK"] +} +HotelService { # Hotel Service +n10: rectangle label:"Reserve Hotel Room" +n11: rectangle label:"Send Hotel Result" +n12: rectangle label:"Forward Hotel ID" +n13: rectangle label:"Cancel Hotel (Compensate)" +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> Saga.n14.handle(bottom) [label="Hotel OK"] +} +CarService { # Car Rental Service +n15: rectangle label:"Reserve Car" +n16: rectangle label:"Send Car Result" +n17: rectangle label:"Forward Car ID" +n18: rectangle label:"Cancel Car (Compensate)" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> Saga.n19.handle(bottom) [label="Car OK"] +} diff --git a/ai-orchestration/patterns/fan-out-fan-in-workflow/README.md b/ai-orchestration/patterns/fan-out-fan-in-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c134d97e681126d0009eed49d5467d3dd50b7a43 --- /dev/null +++ b/ai-orchestration/patterns/fan-out-fan-in-workflow/README.md @@ -0,0 +1,19 @@ +# Fan Out Fan In Workflow + +Fan-out/fan-in pattern with work distribution to parallel workers, concurrent execution, result aggregation, and error handling for partial failures. + +**Template ID:** `fan-out-fan-in-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** ai-orchestration +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [fan-out-fan-in, scatter-gather, parallel-processing, aggregation, map-reduce, concurrency] +**Source path:** `patterns/fan-out-fan-in` +**Repo path:** `ai-orchestration/patterns/fan-out-fan-in-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/ai-orchestration/patterns/fan-out-fan-in-workflow/metadata.json b/ai-orchestration/patterns/fan-out-fan-in-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8ae55e8eb349e485e5524c3677469a87989174d6 --- /dev/null +++ b/ai-orchestration/patterns/fan-out-fan-in-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "fan-out-fan-in-workflow", + "workflow_id": "fan-out-fan-in", + "title": "Fan Out Fan In Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "ai-orchestration", + "secondary_use_cases": [], + "use_cases": [ + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "fan-out-fan-in", + "scatter-gather", + "parallel-processing", + "aggregation", + "map-reduce", + "concurrency" + ], + "description": "Fan-out/fan-in pattern with work distribution to parallel workers, concurrent execution, result aggregation, and error handling for partial failures.", + "source_path": "patterns/fan-out-fan-in", + "repo_path": "ai-orchestration/patterns/fan-out-fan-in-workflow" +} diff --git a/ai-orchestration/patterns/fan-out-fan-in-workflow/workflow.fz b/ai-orchestration/patterns/fan-out-fan-in-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..10689ed4b001adfd9693e00f455dae189abc24e6 --- /dev/null +++ b/ai-orchestration/patterns/fan-out-fan-in-workflow/workflow.fz @@ -0,0 +1,61 @@ +Orchestrator { # Orchestrator +n1: circle label:"Start" +n2: rectangle label:"Receive batch request" +n3: rectangle label:"Split into work items" +n4: rectangle label:"Aggregate results" +n5: rectangle label:"Return combined response" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Worker1.n7.handle(top) [label="Item 1"] +n3.handle(bottom) -> Worker2.n11.handle(top) [label="Item 2"] +n3.handle(bottom) -> Worker3.n15.handle(top) [label="Item 3"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +} +Worker1 { # Worker 1 +n7: rectangle label:"Process work item" +n8: diamond label:"Processing successful?" +n9: rectangle label:"Return result" +n10: rectangle label:"Return error" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(top) -> Aggregator.n19.handle(bottom) [label="Result 1"] +n10.handle(top) -> Aggregator.n19.handle(bottom) [label="Error 1"] +} +Worker2 { # Worker 2 +n11: rectangle label:"Process work item" +n12: diamond label:"Processing successful?" +n13: rectangle label:"Return result" +n14: rectangle label:"Return error" +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) [label="Yes"] +n12.handle(bottom) -> n14.handle(top) [label="No"] +n13.handle(top) -> Aggregator.n19.handle(bottom) [label="Result 2"] +n14.handle(top) -> Aggregator.n19.handle(bottom) [label="Error 2"] +} +Worker3 { # Worker 3 +n15: rectangle label:"Process work item" +n16: diamond label:"Processing successful?" +n17: rectangle label:"Return result" +n18: rectangle label:"Return error" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> n18.handle(top) [label="No"] +n17.handle(top) -> Aggregator.n19.handle(bottom) [label="Result 3"] +n18.handle(top) -> Aggregator.n19.handle(bottom) [label="Error 3"] +} +Aggregator { # Aggregator +n19: rectangle label:"Wait for all workers" +n20: rectangle label:"Combine results" +n21: diamond label:"All succeeded?" +n22: rectangle label:"Return success" +n23: rectangle label:"Return partial failure" +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(right) -> n22.handle(left) [label="Yes"] +n21.handle(bottom) -> n23.handle(top) [label="No"] +n22.handle(top) -> Orchestrator.n4.handle(bottom) [label="Complete"] +n23.handle(top) -> Orchestrator.n4.handle(bottom) [label="Partial"] +} \ No newline at end of file diff --git a/approval/architecture/saga-order-fulfillment-architecture/README.md b/approval/architecture/saga-order-fulfillment-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a9f0bed75ee4a726550b25d1b20ff5706b7c3f08 --- /dev/null +++ b/approval/architecture/saga-order-fulfillment-architecture/README.md @@ -0,0 +1,19 @@ +# Saga Order Fulfillment Architecture + +An order fulfillment saga architecture diagram with four sequential steps: customer verification, inventory reservation, payment authorization, and shipment creation, with a compensation chain that reverses completed steps on failure. This template models the end-to-end order lifecycle as a saga, showing how each service participates in the transaction and how compensating actions maintain data consistency. Ideal for e-commerce architects designing reliable order processing pipelines. + +**Template ID:** `saga-order-fulfillment-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** approval +**Secondary use cases:** billing, security +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 3 +**Tags:** [order-fulfillment, saga-pattern, e-commerce, payment-authorization, inventory-reservation, compensation-chain, distributed-transaction, architecture-diagram] +**Source path:** `` +**Repo path:** `approval/architecture/saga-order-fulfillment-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/architecture/saga-order-fulfillment-architecture/metadata.json b/approval/architecture/saga-order-fulfillment-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..efbaa23e8fb469b10946da456f789b7ea053c967 --- /dev/null +++ b/approval/architecture/saga-order-fulfillment-architecture/metadata.json @@ -0,0 +1,33 @@ +{ + "template_id": "saga-order-fulfillment-architecture", + "workflow_id": "saga-order-fulfillment-architecture", + "title": "Saga Order Fulfillment Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "approval", + "secondary_use_cases": [ + "billing", + "security" + ], + "use_cases": [ + "approval", + "billing", + "security" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 3, + "tags": [ + "order-fulfillment", + "saga-pattern", + "e-commerce", + "payment-authorization", + "inventory-reservation", + "compensation-chain", + "distributed-transaction", + "architecture-diagram" + ], + "description": "An order fulfillment saga architecture diagram with four sequential steps: customer verification, inventory reservation, payment authorization, and shipment creation, with a compensation chain that reverses completed steps on failure. This template models the end-to-end order lifecycle as a saga, showing how each service participates in the transaction and how compensating actions maintain data consistency. Ideal for e-commerce architects designing reliable order processing pipelines.", + "source_path": "", + "repo_path": "approval/architecture/saga-order-fulfillment-architecture" +} diff --git a/approval/architecture/saga-order-fulfillment-architecture/workflow.fz b/approval/architecture/saga-order-fulfillment-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b89d36f7961a9539f6e62402adce91ed54d59a6a --- /dev/null +++ b/approval/architecture/saga-order-fulfillment-architecture/workflow.fz @@ -0,0 +1,70 @@ +OrderSaga { # Order Fulfillment Saga +n1: circle label:"Order Received" +n2: rectangle label:"Validate Order" +n3: rectangle label:"Step 1: Verify Customer" +n8: rectangle label:"Step 2: Check Inventory" +n13: rectangle label:"Step 3: Authorize Payment" +n18: rectangle label:"Step 4: Ship Order" +n23: diamond label:"Saga Complete?" +n24: rectangle label:"Finalize Order" +n25: rectangle label:"Trigger Compensation Chain" +n26: circle label:"Order Fulfilled" +n32: rectangle label:"Rollback Confirmed" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Valid"] +n3.handle(bottom) -> Services.n4.handle(top) [label="Verify"] +n8.handle(bottom) -> Services.n9.handle(top) [label="Reserve"] +n13.handle(bottom) -> Services.n14.handle(top) [label="Charge"] +n18.handle(bottom) -> Services.n19.handle(top) [label="Ship"] +n23.handle(right) -> n24.handle(left) [label="Success"] +n23.handle(bottom) -> n25.handle(top) [label="Failure"] +n24.handle(right) -> n26.handle(left) +n25.handle(bottom) -> Compensations.n27.handle(top) [label="Compensate"] +n32.handle(right) -> n26.handle(left) +} +Services { # Participating Services +n4: rectangle label:"Customer Service" +n5: rectangle label:"Verify Customer" +n6: rectangle label:"Send Verification" +n7: rectangle label:"Forward to Saga" +n9: rectangle label:"Inventory Service" +n10: rectangle label:"Reserve Stock" +n11: rectangle label:"Send Reservation" +n12: rectangle label:"Forward to Saga" +n14: rectangle label:"Payment Service" +n15: rectangle label:"Charge Payment" +n16: rectangle label:"Send Charge Result" +n17: rectangle label:"Forward to Saga" +n19: rectangle label:"Shipping Service" +n20: rectangle label:"Ship Order" +n21: rectangle label:"Send Shipment Status" +n22: rectangle label:"Forward to Saga" +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(top) -> OrderSaga.n8.handle(bottom) [label="Customer OK"] +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> OrderSaga.n13.handle(bottom) [label="Reserved"] +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> OrderSaga.n18.handle(bottom) [label="Charged"] +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(right) -> n22.handle(left) +n22.handle(top) -> OrderSaga.n23.handle(bottom) [label="Shipped"] +} +Compensations { # Compensation Actions +n27: rectangle label:"Reverse Payment" +n28: rectangle label:"Release Inventory" +n29: rectangle label:"Notify Customer" +n30: rectangle label:"Notify Saga" +n31: rectangle label:"Send Rollback Status" +n27.handle(right) -> n28.handle(left) [label="Refund"] +n28.handle(right) -> n29.handle(left) [label="Unreserve"] +n29.handle(right) -> n30.handle(left) [label="Apology Email"] +n30.handle(right) -> n31.handle(left) +n31.handle(top) -> OrderSaga.n32.handle(bottom) [label="Rollback Complete"] +} diff --git a/approval/business-operations/billing-dispute-workflow/README.md b/approval/business-operations/billing-dispute-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..790e768b42a14689dff79da5ddc50b94613ae7de --- /dev/null +++ b/approval/business-operations/billing-dispute-workflow/README.md @@ -0,0 +1,19 @@ +# Billing Dispute Workflow + +Billing dispute workflow with dispute intake, transaction review, fraud analysis, resolution decision, and chargeback response handling. + +**Template ID:** `billing-dispute-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** approval +**Secondary use cases:** billing +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [billing-dispute, chargeback, refund-request, dispute-resolution, fraud-review, stripe] +**Source path:** `business-operations/billing-dispute` +**Repo path:** `approval/business-operations/billing-dispute-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/business-operations/billing-dispute-workflow/metadata.json b/approval/business-operations/billing-dispute-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..daaed49b2784485d8b79c34e0e3f6bbfc6c28aa1 --- /dev/null +++ b/approval/business-operations/billing-dispute-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "billing-dispute-workflow", + "workflow_id": "billing-dispute", + "title": "Billing Dispute Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "approval", + "secondary_use_cases": [ + "billing" + ], + "use_cases": [ + "approval", + "billing" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "billing-dispute", + "chargeback", + "refund-request", + "dispute-resolution", + "fraud-review", + "stripe" + ], + "description": "Billing dispute workflow with dispute intake, transaction review, fraud analysis, resolution decision, and chargeback response handling.", + "source_path": "business-operations/billing-dispute", + "repo_path": "approval/business-operations/billing-dispute-workflow" +} diff --git a/approval/business-operations/billing-dispute-workflow/workflow.fz b/approval/business-operations/billing-dispute-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3145738e5fee7fda7d2e031b2f93dff1c3ffc1e4 --- /dev/null +++ b/approval/business-operations/billing-dispute-workflow/workflow.fz @@ -0,0 +1,45 @@ +Customer { # Customer + n1: circle label:"Start" + n2: rectangle label:"Submit dispute with evidence" + n3: rectangle label:"Receive resolution notification" + n4: diamond label:"Accept resolution?" + n5: rectangle label:"Acknowledge closure" + n6: circle label:"End" + + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Support.n7.handle(top) [label="Open ticket"] + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> n5.handle(left) [label="Yes"] + n4.handle(bottom) -> Support.n12.handle(top) [label="No - Escalate"] + n5.handle(right) -> n6.handle(left) +} +Support { # Support + n7: rectangle label:"Log dispute details" + n8: rectangle label:"Gather transaction history" + n9: diamond label:"Clear billing error?" + n10: rectangle label:"Issue refund or credit" + n11: rectangle label:"Prepare denial explanation" + n12: rectangle label:"Escalate to supervisor" + + n7.handle(right) -> n8.handle(left) + n8.handle(bottom) -> Finance.n13.handle(top) [label="Request review"] + n9.handle(right) -> n10.handle(left) [label="Yes"] + n9.handle(bottom) -> n11.handle(top) [label="No"] + n10.handle(top) -> Customer.n3.handle(bottom) [label="Approved"] + n11.handle(top) -> Customer.n3.handle(bottom) [label="Denied"] + n12.handle(bottom) -> Finance.n16.handle(top) [label="Review needed"] +} +Finance { # Finance + n13: rectangle label:"Verify charges against records" + n14: diamond label:"Discrepancy found?" + n15: rectangle label:"Document findings" + n16: rectangle label:"Manager review" + n17: rectangle label:"Final decision" + + n13.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) [label="Yes"] + n14.handle(bottom) -> n15.handle(bottom) [label="No"] + n15.handle(top) -> Support.n9.handle(bottom) [label="Report"] + n16.handle(right) -> n17.handle(left) + n17.handle(top) -> Customer.n3.handle(bottom) [label="Final resolution"] +} \ No newline at end of file diff --git a/approval/business-operations/oauth-flow-workflow/README.md b/approval/business-operations/oauth-flow-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..850dd4b5aa26eec99b51aac882b32cb24d7e6a8a --- /dev/null +++ b/approval/business-operations/oauth-flow-workflow/README.md @@ -0,0 +1,19 @@ +# Oauth Flow Workflow + +OAuth 2.0 authorization code flow with redirect handling, code exchange, token storage, refresh token rotation, and scope management. + +**Template ID:** `oauth-flow-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** approval +**Secondary use cases:** security +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [oauth-flow, oauth2, authorization-code, token-exchange, sso, third-party-auth] +**Source path:** `business-operations/oauth-flow` +**Repo path:** `approval/business-operations/oauth-flow-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/business-operations/oauth-flow-workflow/metadata.json b/approval/business-operations/oauth-flow-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..86178b094d03f9607c83f5f29d43b76df0edf035 --- /dev/null +++ b/approval/business-operations/oauth-flow-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "oauth-flow-workflow", + "workflow_id": "oauth-flow", + "title": "Oauth Flow Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "approval", + "secondary_use_cases": [ + "security" + ], + "use_cases": [ + "approval", + "security" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "oauth-flow", + "oauth2", + "authorization-code", + "token-exchange", + "sso", + "third-party-auth" + ], + "description": "OAuth 2.0 authorization code flow with redirect handling, code exchange, token storage, refresh token rotation, and scope management.", + "source_path": "business-operations/oauth-flow", + "repo_path": "approval/business-operations/oauth-flow-workflow" +} diff --git a/approval/business-operations/oauth-flow-workflow/workflow.fz b/approval/business-operations/oauth-flow-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..caa38cd5745a0c73706e16043e17c92f73ccd69a --- /dev/null +++ b/approval/business-operations/oauth-flow-workflow/workflow.fz @@ -0,0 +1,43 @@ +User { # User + n1: circle label:"Start" + n2: rectangle label:"Click Login with Provider" + n3: rectangle label:"Grant permissions" + n4: rectangle label:"Receive access token" + n5: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> ClientApp.n6.handle(top) [label="Initiate"] + n3.handle(bottom) -> AuthServer.n12.handle(top) [label="Approve"] + n4.handle(right) -> n5.handle(left) +} +ClientApp { # Client App + n6: rectangle label:"Generate state parameter" + n7: rectangle label:"Build authorization URL" + n8: rectangle label:"Redirect to auth server" + n9: rectangle label:"Receive authorization code" + n10: rectangle label:"Exchange code for tokens" + n11: rectangle label:"Store tokens securely" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n8.handle(bottom) -> AuthServer.n13.handle(top) [label="Redirect"] + n9.handle(right) -> n10.handle(left) + n10.handle(bottom) -> AuthServer.n17.handle(top) [label="Token request"] + n11.handle(top) -> User.n4.handle(bottom) [label="Authenticated"] +} +AuthServer { # Auth Server + n12: rectangle label:"Validate client credentials" + n13: rectangle label:"Display consent screen" + n14: diamond label:"User consents?" + n15: rectangle label:"Generate authorization code" + n16: rectangle label:"Return error response" + n17: diamond label:"Valid code and secret?" + n18: rectangle label:"Issue access and refresh tokens" + n12.handle(right) -> n13.handle(left) + n13.handle(top) -> User.n3.handle(bottom) [label="Show consent"] + n14.handle(right) -> n15.handle(left) [label="Yes"] + n14.handle(bottom) -> n16.handle(top) [label="No"] + n15.handle(top) -> ClientApp.n9.handle(bottom) [label="Callback"] + n16.handle(top) -> ClientApp.n6.handle(bottom) [label="Access denied"] + n17.handle(right) -> n18.handle(left) [label="Yes"] + n17.handle(bottom) -> n16.handle(left) [label="No"] + n18.handle(top) -> ClientApp.n11.handle(bottom) [label="Tokens"] +} \ No newline at end of file diff --git a/approval/business-operations/review-collection-workflow/README.md b/approval/business-operations/review-collection-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1f828a5a9fea44d5c5e9101f4daff3c5270fe248 --- /dev/null +++ b/approval/business-operations/review-collection-workflow/README.md @@ -0,0 +1,19 @@ +# Review Collection Workflow + +Customer review collection workflow with post-purchase trigger, review request email, rating submission, moderation, and public display. + +**Template ID:** `review-collection-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** approval +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [review-collection, customer-feedback, nps, ratings, social-proof, testimonials] +**Source path:** `business-operations/review-collection` +**Repo path:** `approval/business-operations/review-collection-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/business-operations/review-collection-workflow/metadata.json b/approval/business-operations/review-collection-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6968e9af5b6fe1025ae9eabef5cfd20b376b84cd --- /dev/null +++ b/approval/business-operations/review-collection-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "review-collection-workflow", + "workflow_id": "review-collection", + "title": "Review Collection Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "approval", + "secondary_use_cases": [], + "use_cases": [ + "approval" + ], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "review-collection", + "customer-feedback", + "nps", + "ratings", + "social-proof", + "testimonials" + ], + "description": "Customer review collection workflow with post-purchase trigger, review request email, rating submission, moderation, and public display.", + "source_path": "business-operations/review-collection", + "repo_path": "approval/business-operations/review-collection-workflow" +} diff --git a/approval/business-operations/review-collection-workflow/workflow.fz b/approval/business-operations/review-collection-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..be14e2ee80d834a9c32b687fed2e77227c468949 --- /dev/null +++ b/approval/business-operations/review-collection-workflow/workflow.fz @@ -0,0 +1,57 @@ +n8nSchedule { # n8n Schedule Trigger + n1: circle label:"Start" + n2: rectangle label:"Trigger daily at 10 AM" + n3: rectangle label:"Query Shopify orders" + n4: rectangle label:"Filter delivered 7 days ago" + n5: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(right) -> n4.handle(left) + n4.handle(bottom) -> n8nFilter.n6.handle(top) [label="Filtered orders"] +} + +n8nFilter { # n8n Filter Node + n6: rectangle label:"Check if review exists" + n7: diamond label:"Already reviewed?" + n8: rectangle label:"Skip customer" + n9: rectangle label:"Add to review queue" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) [label="Yes"] + n7.handle(bottom) -> n9.handle(top) [label="No"] + n8.handle(top) -> n8nSchedule.n5.handle(bottom) [label="Skip"] + n9.handle(bottom) -> n8nEmail.n10.handle(top) [label="Request review"] +} + +n8nEmail { # n8n SendGrid Node + n10: rectangle label:"Build personalized email" + n11: rectangle label:"Include product image" + n12: rectangle label:"Add review link with token" + n13: rectangle label:"Send via SendGrid API" + n14: diamond label:"Email sent?" + n15: rectangle label:"Log to Google Sheets" + n16: rectangle label:"Queue for retry" + n10.handle(right) -> n11.handle(left) + n11.handle(right) -> n12.handle(left) + n12.handle(right) -> n13.handle(left) + n13.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) [label="Yes"] + n14.handle(bottom) -> n16.handle(top) [label="No"] + n15.handle(bottom) -> n8nWebhook.n17.handle(top) [label="Track"] + n16.handle(top) -> n13.handle(bottom) [label="Retry"] +} + +n8nWebhook { # n8n Webhook Response + n17: rectangle label:"Wait for review submission" + n18: rectangle label:"Validate review content" + n19: diamond label:"Rating 4 or 5 stars?" + n20: rectangle label:"Post to Trustpilot API" + n21: rectangle label:"Flag for internal review" + n22: rectangle label:"Send thank you email" + n17.handle(right) -> n18.handle(left) + n18.handle(right) -> n19.handle(left) + n19.handle(right) -> n20.handle(left) [label="Yes"] + n19.handle(bottom) -> n21.handle(top) [label="No"] + n20.handle(right) -> n22.handle(left) + n21.handle(right) -> n22.handle(top) + n22.handle(top) -> n8nSchedule.n5.handle(bottom) [label="Complete"] +} \ No newline at end of file diff --git a/approval/devops/access-review-workflow/README.md b/approval/devops/access-review-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..01cca2429125eac4b87ee2b60c82c5f6071368de --- /dev/null +++ b/approval/devops/access-review-workflow/README.md @@ -0,0 +1,19 @@ +# Access Review Workflow + +Quarterly user access review workflow with manager certification, separation of duties validation, remediation tracking, and compliance reporting for audit purposes. + +**Template ID:** `access-review-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** approval +**Secondary use cases:** compliance +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 3 +**Tags:** [access-review, user-access-certification, quarterly-review, manager-approval, compliance, sod-violations, audit] +**Source path:** `devops/access-review` +**Repo path:** `approval/devops/access-review-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/devops/access-review-workflow/metadata.json b/approval/devops/access-review-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..0a7a6fa77461f810c573b9ff257b1ce7831d6c63 --- /dev/null +++ b/approval/devops/access-review-workflow/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "access-review-workflow", + "workflow_id": "access-review", + "title": "Access Review Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "approval", + "secondary_use_cases": [ + "compliance" + ], + "use_cases": [ + "approval", + "compliance" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 3, + "tags": [ + "access-review", + "user-access-certification", + "quarterly-review", + "manager-approval", + "compliance", + "sod-violations", + "audit" + ], + "description": "Quarterly user access review workflow with manager certification, separation of duties validation, remediation tracking, and compliance reporting for audit purposes.", + "source_path": "devops/access-review", + "repo_path": "approval/devops/access-review-workflow" +} diff --git a/approval/devops/access-review-workflow/workflow.fz b/approval/devops/access-review-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d3a59901dca854b2cc70e5a2d4bf9e0c0447dcf0 --- /dev/null +++ b/approval/devops/access-review-workflow/workflow.fz @@ -0,0 +1,45 @@ +IAM { # Identity Management +n1: circle label:"Start" +n2: rectangle label:"Initiate quarterly review" +n3: rectangle label:"Generate access report" +n4: rectangle label:"Complete review cycle" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Manager.n6.handle(top) [label="Review needed"] +n4.handle(right) -> n5.handle(left) +} +Manager { # Manager Review +n6: rectangle label:"Review direct reports access" +n7: diamond label:"Access appropriate?" +n8: rectangle label:"Certify access" +n9: rectangle label:"Flag for removal" +n10: rectangle label:"Request justification" +n11: diamond label:"More users to review?" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(bottom) -> n9.handle(top) [label="No"] +n7.handle(left) -> n10.handle(top) [label="Unsure"] +n8.handle(right) -> n11.handle(left) +n9.handle(right) -> n11.handle(top) +n10.handle(right) -> n7.handle(top) +n11.handle(right) -> n6.handle(bottom) [label="Yes"] +n11.handle(bottom) -> Remediation.n12.handle(top) [label="No"] +} +Remediation { # Access Remediation +n12: rectangle label:"Collect flagged accounts" +n13: rectangle label:"Disable excess permissions" +n14: rectangle label:"Remove orphaned accounts" +n15: diamond label:"Exceptions requested?" +n16: rectangle label:"Route to security team" +n17: rectangle label:"Generate compliance report" +n18: rectangle label:"Archive review evidence" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(right) -> n17.handle(top) +n17.handle(right) -> n18.handle(left) +n18.handle(top) -> IAM.n4.handle(bottom) [label="Complete"] +} \ No newline at end of file diff --git a/approval/devops/database-migration-workflow/README.md b/approval/devops/database-migration-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7dfd28f0c5d0013f45d0d0c6763e71f0a139bdab --- /dev/null +++ b/approval/devops/database-migration-workflow/README.md @@ -0,0 +1,19 @@ +# Database Migration Workflow + +Database schema migration workflow with CI testing, DBA review and approval, maintenance window scheduling, backup snapshots, migration execution, data integrity verification, and automatic rollback. + +**Template ID:** `database-migration-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** approval +**Secondary use cases:** delivery +**Complexity:** 4/5 +**Nodes:** 20 +**Lanes:** 4 +**Tags:** [database-migration, schema-changes, flyway, liquibase, rollback, dba-approval, maintenance-window] +**Source path:** `devops/database-migration` +**Repo path:** `approval/devops/database-migration-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/devops/database-migration-workflow/metadata.json b/approval/devops/database-migration-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4404d3af209ad96f939a8a6c832b2ec3253213dd --- /dev/null +++ b/approval/devops/database-migration-workflow/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "database-migration-workflow", + "workflow_id": "database-migration", + "title": "Database Migration Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "approval", + "secondary_use_cases": [ + "delivery" + ], + "use_cases": [ + "approval", + "delivery" + ], + "complexity": 4, + "num_nodes": 20, + "num_lanes": 4, + "tags": [ + "database-migration", + "schema-changes", + "flyway", + "liquibase", + "rollback", + "dba-approval", + "maintenance-window" + ], + "description": "Database schema migration workflow with CI testing, DBA review and approval, maintenance window scheduling, backup snapshots, migration execution, data integrity verification, and automatic rollback.", + "source_path": "devops/database-migration", + "repo_path": "approval/devops/database-migration-workflow" +} diff --git a/approval/devops/database-migration-workflow/workflow.fz b/approval/devops/database-migration-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..89a9a896d1ecfcfb2d273e61bd775aeb069d4a8b --- /dev/null +++ b/approval/devops/database-migration-workflow/workflow.fz @@ -0,0 +1,50 @@ +Developer { # Developer +n1: circle label:"Start" +n2: rectangle label:"Create migration script" +n3: rectangle label:"Test locally" +n4: rectangle label:"Review migration results" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> CI.n6.handle(top) [label="Push to repo"] +n4.handle(right) -> n5.handle(left) +} +CI { # CI Pipeline +n6: rectangle label:"Run migration in test DB" +n7: diamond label:"Migration successful?" +n8: rectangle label:"Generate rollback script" +n9: rectangle label:"Fail build with errors" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(bottom) -> n9.handle(top) [label="No"] +n8.handle(bottom) -> DBA.n10.handle(top) [label="Approve"] +n9.handle(top) -> Developer.n2.handle(bottom) [label="Fix script"] +} +DBA { # Database Admin +n10: rectangle label:"Review migration plan" +n11: diamond label:"Approve for production?" +n12: rectangle label:"Schedule maintenance window" +n13: rectangle label:"Request changes" +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(bottom) -> Production.n14.handle(top) [label="Execute"] +n13.handle(top) -> Developer.n2.handle(bottom) [label="Revise"] +} +Production { # Production Database +n14: rectangle label:"Create backup snapshot" +n15: rectangle label:"Enable maintenance mode" +n16: rectangle label:"Execute migration script" +n17: diamond label:"Migration completed?" +n18: rectangle label:"Verify data integrity" +n19: rectangle label:"Execute rollback script" +n20: rectangle label:"Disable maintenance mode" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(right) -> n20.handle(left) +n19.handle(right) -> n20.handle(top) +n20.handle(top) -> Developer.n4.handle(bottom) [label="Complete"] +} diff --git a/approval/finance/budget-approval-workflow/README.md b/approval/finance/budget-approval-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..82d182adf65b4e931026f1105ddd1740061a1563 --- /dev/null +++ b/approval/finance/budget-approval-workflow/README.md @@ -0,0 +1,19 @@ +# Budget Approval Workflow + +Corporate budget approval workflow with tiered approval routing based on amount thresholds (CFO < $100K, CEO $100K-$1M, Board > $1M), prior year comparison, and fund allocation. + +**Template ID:** `budget-approval-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** approval +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 3 +**Tags:** [budget-approval, financial-planning, tiered-approval, cfo-approval, ceo-approval, board-approval, fund-allocation] +**Source path:** `finance/budget-approval` +**Repo path:** `approval/finance/budget-approval-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/finance/budget-approval-workflow/metadata.json b/approval/finance/budget-approval-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..080c31fbcc93acc3ebebf84c54a28a4765bab15e --- /dev/null +++ b/approval/finance/budget-approval-workflow/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "budget-approval-workflow", + "workflow_id": "budget-approval", + "title": "Budget Approval Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "approval", + "secondary_use_cases": [], + "use_cases": [ + "approval" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 3, + "tags": [ + "budget-approval", + "financial-planning", + "tiered-approval", + "cfo-approval", + "ceo-approval", + "board-approval", + "fund-allocation" + ], + "description": "Corporate budget approval workflow with tiered approval routing based on amount thresholds (CFO < $100K, CEO $100K-$1M, Board > $1M), prior year comparison, and fund allocation.", + "source_path": "finance/budget-approval", + "repo_path": "approval/finance/budget-approval-workflow" +} diff --git a/approval/finance/budget-approval-workflow/workflow.fz b/approval/finance/budget-approval-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0194e8898b1a50820d6b04e64def8be2eecf1e98 --- /dev/null +++ b/approval/finance/budget-approval-workflow/workflow.fz @@ -0,0 +1,48 @@ +DeptManager { # Department Manager +n1: circle label:"Start" +n2: rectangle label:"Submit budget request" +n3: rectangle label:"Justify line items" +n4: rectangle label:"Receive approval status" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Finance.n6.handle(top) [label="Submit"] +n4.handle(right) -> n5.handle(left) +} +Finance { # Finance Department +n6: rectangle label:"Review budget request" +n7: rectangle label:"Compare to prior year" +n8: diamond label:"Within guidelines?" +n9: rectangle label:"Recommend approval" +n10: rectangle label:"Request justification" +n11: rectangle label:"Recommend reduction" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="Need info"] +n8.handle(left) -> n11.handle(top) [label="Over budget"] +n9.handle(bottom) -> Executive.n12.handle(top) [label="Forward"] +n10.handle(top) -> DeptManager.n3.handle(bottom) [label="Revise"] +n11.handle(bottom) -> Executive.n12.handle(top) [label="Forward"] +} +Executive { # Executive Approval +n12: rectangle label:"Review budget package" +n13: diamond label:"Budget amount?" +n14: rectangle label:"CFO approval" +n15: rectangle label:"CEO approval" +n16: rectangle label:"Board approval" +n17: diamond label:"Approved?" +n18: rectangle label:"Allocate funds" +n19: rectangle label:"Return for revision" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="< $100K"] +n13.handle(bottom) -> n15.handle(top) [label="$100K-$1M"] +n13.handle(left) -> n16.handle(top) [label="> $1M"] +n14.handle(bottom) -> n17.handle(top) +n15.handle(bottom) -> n17.handle(top) +n16.handle(bottom) -> n17.handle(top) +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(top) -> DeptManager.n4.handle(bottom) [label="Approved"] +n19.handle(top) -> DeptManager.n3.handle(bottom) [label="Revise"] +} diff --git a/approval/finance/expense-claim-workflow/README.md b/approval/finance/expense-claim-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a8f1b077cf0df8168952dbeb26f85252ec841771 --- /dev/null +++ b/approval/finance/expense-claim-workflow/README.md @@ -0,0 +1,19 @@ +# Expense Claim Workflow + +Employee expense reimbursement workflow with receipt submission, manager approval, finance review, policy compliance check, and direct deposit payment. + +**Template ID:** `expense-claim-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** approval +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [expense-reimbursement, employee-expenses, receipt-upload, manager-approval, finance-review, direct-deposit] +**Source path:** `finance/expense-claim` +**Repo path:** `approval/finance/expense-claim-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/finance/expense-claim-workflow/metadata.json b/approval/finance/expense-claim-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4c6fc2c3318d522540aa346977e3906d799622f8 --- /dev/null +++ b/approval/finance/expense-claim-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "expense-claim-workflow", + "workflow_id": "expense-claim", + "title": "Expense Claim Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "approval", + "secondary_use_cases": [], + "use_cases": [ + "approval" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "expense-reimbursement", + "employee-expenses", + "receipt-upload", + "manager-approval", + "finance-review", + "direct-deposit" + ], + "description": "Employee expense reimbursement workflow with receipt submission, manager approval, finance review, policy compliance check, and direct deposit payment.", + "source_path": "finance/expense-claim", + "repo_path": "approval/finance/expense-claim-workflow" +} diff --git a/approval/finance/expense-claim-workflow/workflow.fz b/approval/finance/expense-claim-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..63c2cbdc967e7d6be26f05caa98e181dafef194a --- /dev/null +++ b/approval/finance/expense-claim-workflow/workflow.fz @@ -0,0 +1,27 @@ +employee { # Employee + n1: circle label:"Start Expense Claim" + n4: rectangle label:"Make Expense Claim decision" + n7: rectangle label:"Continue Expense Claim process" + n10: circle label:"End Expense Claim" + n1.handle(bottom) -> manager.n2.handle(top) + n4.handle(bottom) -> manager.n5.handle(top) + n7.handle(bottom) -> manager.n8.handle(top) +} + +manager { # Manager + n2: rectangle label:"Receive Expense Claim request" + n5: rectangle label:"Update records for Expense Claim" + n8: rectangle label:"Continue Expense Claim process" + n2.handle(bottom) -> finance_app.n3.handle(top) [label="Next"] + n5.handle(bottom) -> finance_app.n6.handle(top) [label="Done"] + n8.handle(bottom) -> finance_app.n9.handle(top) [label="Processed"] +} + +finance_app { # Finance_App + n3: rectangle label:"Review Expense Claim details" + n6: rectangle label:"Continue Expense Claim process" + n9: rectangle label:"Continue Expense Claim process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n7.handle(left) + n3.handle(right) -> employee.n4.handle(left) +} diff --git a/approval/finance/insurance-claim-workflow/README.md b/approval/finance/insurance-claim-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ab7c8d6b861b9100780778861ea5f0bc02cc9896 --- /dev/null +++ b/approval/finance/insurance-claim-workflow/README.md @@ -0,0 +1,19 @@ +# Insurance Claim Workflow + +Insurance claim processing workflow with incident documentation, claim filing, adjuster assignment, damage assessment, and settlement negotiation. + +**Template ID:** `insurance-claim-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** approval +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [insurance-claim, claim-filing, adjuster-review, settlement, property-damage, liability] +**Source path:** `finance/insurance-claim` +**Repo path:** `approval/finance/insurance-claim-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/finance/insurance-claim-workflow/metadata.json b/approval/finance/insurance-claim-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..915af17c66215b4d06f7c0b559ed06f657b63fad --- /dev/null +++ b/approval/finance/insurance-claim-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "insurance-claim-workflow", + "workflow_id": "insurance-claim", + "title": "Insurance Claim Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "approval", + "secondary_use_cases": [], + "use_cases": [ + "approval" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "insurance-claim", + "claim-filing", + "adjuster-review", + "settlement", + "property-damage", + "liability" + ], + "description": "Insurance claim processing workflow with incident documentation, claim filing, adjuster assignment, damage assessment, and settlement negotiation.", + "source_path": "finance/insurance-claim", + "repo_path": "approval/finance/insurance-claim-workflow" +} diff --git a/approval/finance/insurance-claim-workflow/workflow.fz b/approval/finance/insurance-claim-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c07717b0f7696774e7bc3e14ecc69a55a8e6aea8 --- /dev/null +++ b/approval/finance/insurance-claim-workflow/workflow.fz @@ -0,0 +1,19 @@ +employee { # Employee + n1: circle label:"Start Insurance Claim" + n2: diamond label:"Receive Insurance Claim request" + n3: rectangle label:"Review Insurance Claim details" + n5: rectangle label:"Update records for Insurance Claim" + n7: circle label:"End Insurance Claim" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> manager.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> manager.n6.handle(top) +} + +manager { # Manager + n4: rectangle label:"Make Insurance Claim decision" + n6: rectangle label:"Continue Insurance Claim process" + n6.handle(right) -> employee.n7.handle(bottom) + n4.handle(right) -> employee.n5.handle(top) +} diff --git a/approval/finance/invoice-processing-workflow/README.md b/approval/finance/invoice-processing-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..97bbadd172df9bf83c46460ec3674a9f25e1fba5 --- /dev/null +++ b/approval/finance/invoice-processing-workflow/README.md @@ -0,0 +1,19 @@ +# Invoice Processing Workflow + +Accounts payable invoice automation with OCR data extraction, three-way PO matching, tiered approval workflow, and automated payment processing with GL updates. + +**Template ID:** `invoice-processing-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** approval +**Secondary use cases:** billing +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 4 +**Tags:** [accounts-payable, invoice-automation, ocr, po-matching, approval-workflow, payment-processing, three-way-match] +**Source path:** `finance/invoice-processing` +**Repo path:** `approval/finance/invoice-processing-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/finance/invoice-processing-workflow/metadata.json b/approval/finance/invoice-processing-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f6492e202a323db1901e069241ebef674d90a79f --- /dev/null +++ b/approval/finance/invoice-processing-workflow/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "invoice-processing-workflow", + "workflow_id": "invoice-processing", + "title": "Invoice Processing Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "approval", + "secondary_use_cases": [ + "billing" + ], + "use_cases": [ + "approval", + "billing" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 4, + "tags": [ + "accounts-payable", + "invoice-automation", + "ocr", + "po-matching", + "approval-workflow", + "payment-processing", + "three-way-match" + ], + "description": "Accounts payable invoice automation with OCR data extraction, three-way PO matching, tiered approval workflow, and automated payment processing with GL updates.", + "source_path": "finance/invoice-processing", + "repo_path": "approval/finance/invoice-processing-workflow" +} diff --git a/approval/finance/invoice-processing-workflow/workflow.fz b/approval/finance/invoice-processing-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..4774416e6101bc6753f2813abe49b8b544511841 --- /dev/null +++ b/approval/finance/invoice-processing-workflow/workflow.fz @@ -0,0 +1,49 @@ +Vendor { # Vendor +n1: circle label:"Start" +n2: rectangle label:"Submit invoice via email" +n3: rectangle label:"Receive payment notification" +n4: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> APAutomation.n5.handle(top) [label="Invoice received"] +n3.handle(right) -> n4.handle(left) +} +APAutomation { # AP Automation +n5: rectangle label:"Extract invoice data via OCR" +n6: rectangle label:"Match to purchase order" +n7: diamond label:"PO match found?" +n8: rectangle label:"Auto-approve for payment" +n9: rectangle label:"Flag for manual review" +n10: diamond label:"Amount within threshold?" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n10.handle(left) [label="Yes"] +n7.handle(bottom) -> n9.handle(top) [label="No"] +n10.handle(right) -> n8.handle(left) [label="Yes"] +n10.handle(bottom) -> Approvals.n11.handle(top) [label="No"] +n8.handle(bottom) -> Payment.n16.handle(top) [label="Queue payment"] +n9.handle(bottom) -> Approvals.n11.handle(top) [label="Review"] +} +Approvals { # Approval Workflow +n11: rectangle label:"Route to department manager" +n12: diamond label:"Manager approved?" +n13: rectangle label:"Route to finance director" +n14: diamond label:"Director approved?" +n15: rectangle label:"Reject with reason" +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) [label="Yes - Over limit"] +n12.handle(bottom) -> n15.handle(top) [label="No"] +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> Payment.n16.handle(top) [label="Yes"] +n14.handle(bottom) -> n15.handle(top) [label="No"] +n15.handle(top) -> Vendor.n3.handle(bottom) [label="Rejected"] +} +Payment { # Payment Processing +n16: rectangle label:"Schedule payment batch" +n17: rectangle label:"Execute bank transfer" +n18: rectangle label:"Update GL entries" +n19: rectangle label:"Send remittance advice" +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> Vendor.n3.handle(bottom) [label="Payment sent"] +} diff --git a/approval/finance/purchase-order-workflow/README.md b/approval/finance/purchase-order-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..75aca2e3a80031634c80f6f3ee1d3f04a3fd5fcb --- /dev/null +++ b/approval/finance/purchase-order-workflow/README.md @@ -0,0 +1,19 @@ +# Purchase Order Workflow + +Procurement purchase order workflow with requisition creation, budget validation, vendor sourcing, competitive bidding, and tiered approval routing based on amount thresholds. + +**Template ID:** `purchase-order-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** approval +**Secondary use cases:** ai-orchestration +**Complexity:** 4/5 +**Nodes:** 22 +**Lanes:** 3 +**Tags:** [purchase-order, procurement, requisition, vendor-sourcing, competitive-bidding, tiered-approval, budget-validation] +**Source path:** `finance/purchase-order` +**Repo path:** `approval/finance/purchase-order-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/finance/purchase-order-workflow/metadata.json b/approval/finance/purchase-order-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..69a18c614229721979a5d230126b8b42539032fb --- /dev/null +++ b/approval/finance/purchase-order-workflow/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "purchase-order-workflow", + "workflow_id": "purchase-order", + "title": "Purchase Order Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "approval", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "approval", + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 22, + "num_lanes": 3, + "tags": [ + "purchase-order", + "procurement", + "requisition", + "vendor-sourcing", + "competitive-bidding", + "tiered-approval", + "budget-validation" + ], + "description": "Procurement purchase order workflow with requisition creation, budget validation, vendor sourcing, competitive bidding, and tiered approval routing based on amount thresholds.", + "source_path": "finance/purchase-order", + "repo_path": "approval/finance/purchase-order-workflow" +} diff --git a/approval/finance/purchase-order-workflow/workflow.fz b/approval/finance/purchase-order-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3779e55b88cc3c96ab9e9d8c0d86c1d8d23e7343 --- /dev/null +++ b/approval/finance/purchase-order-workflow/workflow.fz @@ -0,0 +1,54 @@ +Requester { # Requester +n1: circle label:"Start" +n2: rectangle label:"Create purchase requisition" +n3: rectangle label:"Add line items" +n4: rectangle label:"Attach specifications" +n5: rectangle label:"Receive PO number" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(bottom) -> Procurement.n7.handle(top) [label="Submit"] +n5.handle(right) -> n6.handle(left) +} +Procurement { # Procurement +n7: rectangle label:"Review requisition" +n8: diamond label:"Budget available?" +n9: rectangle label:"Source vendors" +n10: rectangle label:"Request quotes" +n11: rectangle label:"Return for budget approval" +n12: diamond label:"Competitive bids required?" +n13: rectangle label:"Select best vendor" +n14: rectangle label:"Single source justification" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n11.handle(top) [label="No"] +n9.handle(right) -> n12.handle(left) +n11.handle(top) -> Requester.n2.handle(bottom) [label="Revise"] +n12.handle(right) -> n10.handle(left) [label="Yes"] +n12.handle(bottom) -> n14.handle(top) [label="No"] +n10.handle(right) -> n13.handle(left) +n13.handle(bottom) -> Approval.n15.handle(top) [label="Approve"] +n14.handle(right) -> n13.handle(top) +} +Approval { # Approval Chain +n15: rectangle label:"Route based on amount" +n16: diamond label:"Amount threshold?" +n17: rectangle label:"Manager approval" +n18: rectangle label:"Director approval" +n19: rectangle label:"VP approval" +n20: diamond label:"Approved?" +n21: rectangle label:"Generate PO number" +n22: rectangle label:"Reject with comments" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="< $5K"] +n16.handle(bottom) -> n18.handle(top) [label="$5K-$50K"] +n16.handle(left) -> n19.handle(top) [label="> $50K"] +n17.handle(bottom) -> n20.handle(top) +n18.handle(bottom) -> n20.handle(top) +n19.handle(bottom) -> n20.handle(top) +n20.handle(right) -> n21.handle(left) [label="Yes"] +n20.handle(bottom) -> n22.handle(top) [label="No"] +n21.handle(top) -> Requester.n5.handle(bottom) [label="PO issued"] +n22.handle(top) -> Requester.n2.handle(bottom) [label="Rejected"] +} diff --git a/approval/hr/expense-approval-workflow/README.md b/approval/hr/expense-approval-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b5cd0084a4ac0f00080ee0bc9275024f7334bf7c --- /dev/null +++ b/approval/hr/expense-approval-workflow/README.md @@ -0,0 +1,19 @@ +# Expense Approval Workflow + +Employee expense approval workflow with receipt validation, policy compliance check, tiered approval based on amount, and reimbursement processing. + +**Template ID:** `expense-approval-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** approval +**Secondary use cases:** compliance +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [expense-approval, travel-expenses, receipt-validation, policy-compliance, tiered-approval, reimbursement] +**Source path:** `hr/expense-approval` +**Repo path:** `approval/hr/expense-approval-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/hr/expense-approval-workflow/metadata.json b/approval/hr/expense-approval-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9971bc21aa06610b4d812855c059b7655ff8b82b --- /dev/null +++ b/approval/hr/expense-approval-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "expense-approval-workflow", + "workflow_id": "expense-approval", + "title": "Expense Approval Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "approval", + "secondary_use_cases": [ + "compliance" + ], + "use_cases": [ + "approval", + "compliance" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "expense-approval", + "travel-expenses", + "receipt-validation", + "policy-compliance", + "tiered-approval", + "reimbursement" + ], + "description": "Employee expense approval workflow with receipt validation, policy compliance check, tiered approval based on amount, and reimbursement processing.", + "source_path": "hr/expense-approval", + "repo_path": "approval/hr/expense-approval-workflow" +} diff --git a/approval/hr/expense-approval-workflow/workflow.fz b/approval/hr/expense-approval-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..eddaccbe67ab0d2800e9b05f13d8cc07cf372b64 --- /dev/null +++ b/approval/hr/expense-approval-workflow/workflow.fz @@ -0,0 +1,51 @@ +Employee { # Employee +n1: circle label:"Start" +n2: rectangle label:"Submit expense report" +n3: rectangle label:"Attach receipts" +n4: rectangle label:"Receive reimbursement" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> ExpenseSystem.n6.handle(top) [label="Submit"] +n4.handle(right) -> n5.handle(left) +} +ExpenseSystem { # Expense System +n6: rectangle label:"Validate receipt images" +n7: rectangle label:"Extract expense data via OCR" +n8: diamond label:"Policy compliant?" +n9: rectangle label:"Auto-approve under threshold" +n10: rectangle label:"Flag policy violation" +n11: rectangle label:"Route for approval" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes - Under $100"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n8.handle(left) -> n11.handle(top) [label="Yes - Over $100"] +n9.handle(bottom) -> Finance.n17.handle(top) [label="Queue payment"] +n10.handle(top) -> Employee.n2.handle(bottom) [label="Revise"] +n11.handle(bottom) -> Manager.n12.handle(top) [label="Review"] +} +Manager { # Manager +n12: rectangle label:"Review expense details" +n13: diamond label:"Approve expense?" +n14: rectangle label:"Add approval note" +n15: rectangle label:"Reject with reason" +n16: rectangle label:"Request clarification" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Yes"] +n13.handle(bottom) -> n15.handle(top) [label="No"] +n13.handle(left) -> n16.handle(top) [label="Need info"] +n14.handle(bottom) -> Finance.n17.handle(top) [label="Approved"] +n15.handle(top) -> Employee.n2.handle(bottom) [label="Rejected"] +n16.handle(top) -> Employee.n3.handle(bottom) [label="Update"] +} +Finance { # Finance +n17: rectangle label:"Schedule reimbursement" +n18: rectangle label:"Process direct deposit" +n19: rectangle label:"Update GL accounts" +n20: rectangle label:"Send confirmation email" +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(top) -> Employee.n4.handle(bottom) [label="Paid"] +} diff --git a/approval/hr/performance-review-workflow/README.md b/approval/hr/performance-review-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1885370cd421b0f57335f674a9390b9aabf5e3a7 --- /dev/null +++ b/approval/hr/performance-review-workflow/README.md @@ -0,0 +1,19 @@ +# Performance Review Workflow + +Annual performance review workflow with self-assessment, manager evaluation, 360 feedback collection, calibration sessions, and merit increase recommendations. + +**Template ID:** `performance-review-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** approval +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [performance-review, annual-evaluation, goal-setting, 360-feedback, calibration, merit-increase] +**Source path:** `hr/performance-review` +**Repo path:** `approval/hr/performance-review-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/hr/performance-review-workflow/metadata.json b/approval/hr/performance-review-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..db8713637db71319b6102e387ec01a5a04cb9698 --- /dev/null +++ b/approval/hr/performance-review-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "performance-review-workflow", + "workflow_id": "performance-review", + "title": "Performance Review Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "approval", + "secondary_use_cases": [], + "use_cases": [ + "approval" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "performance-review", + "annual-evaluation", + "goal-setting", + "360-feedback", + "calibration", + "merit-increase" + ], + "description": "Annual performance review workflow with self-assessment, manager evaluation, 360 feedback collection, calibration sessions, and merit increase recommendations.", + "source_path": "hr/performance-review", + "repo_path": "approval/hr/performance-review-workflow" +} diff --git a/approval/hr/performance-review-workflow/workflow.fz b/approval/hr/performance-review-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..00959febb0244d284598ab1ac0c7eeff59704d71 --- /dev/null +++ b/approval/hr/performance-review-workflow/workflow.fz @@ -0,0 +1,54 @@ +Employee { # Employee +n1: circle label:"Start" +n2: rectangle label:"Complete self-assessment" +n3: rectangle label:"Submit goals for next period" +n4: rectangle label:"Attend review meeting" +n5: rectangle label:"Acknowledge review" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> HRSystem.n7.handle(top) [label="Submit"] +n3.handle(bottom) -> Manager.n12.handle(top) [label="Goals ready"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +} +HRSystem { # HR System +n7: rectangle label:"Initiate review cycle" +n8: rectangle label:"Send review reminders" +n9: rectangle label:"Collect 360 feedback" +n10: diamond label:"All feedback received?" +n11: rectangle label:"Send reminder to pending" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> Manager.n12.handle(left) [label="Yes"] +n10.handle(bottom) -> n11.handle(top) [label="No"] +n11.handle(left) -> n9.handle(bottom) [label="Wait"] +} +Manager { # Manager +n12: rectangle label:"Review self-assessment" +n13: rectangle label:"Add manager evaluation" +n14: rectangle label:"Assign performance rating" +n15: diamond label:"Rating calibrated?" +n16: rectangle label:"Schedule review meeting" +n17: rectangle label:"Adjust after calibration" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(top) -> Employee.n4.handle(bottom) [label="Meeting set"] +n17.handle(top) -> n14.handle(bottom) [label="Recalibrate"] +} +Compensation { # Compensation +n18: rectangle label:"Calculate merit increase" +n19: diamond label:"Budget available?" +n20: rectangle label:"Apply salary adjustment" +n21: rectangle label:"Defer to next cycle" +n22: rectangle label:"Update employee record" +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) [label="Yes"] +n19.handle(bottom) -> n21.handle(top) [label="No"] +n20.handle(right) -> n22.handle(left) +n21.handle(right) -> n22.handle(top) +n22.handle(top) -> Employee.n3.handle(bottom) [label="Review complete"] +} diff --git a/approval/hr/pto-request-workflow/README.md b/approval/hr/pto-request-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6d8472d3061594284ac2e5e95347965b3abd1ef7 --- /dev/null +++ b/approval/hr/pto-request-workflow/README.md @@ -0,0 +1,19 @@ +# Pto Request Workflow + +PTO request workflow with balance verification, manager approval, calendar blocking, and team coverage check before approval. + +**Template ID:** `pto-request-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** approval +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [pto-request, time-off, vacation, leave-management, manager-approval, accrual-balance] +**Source path:** `hr/pto-request` +**Repo path:** `approval/hr/pto-request-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/hr/pto-request-workflow/metadata.json b/approval/hr/pto-request-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..36e7d75e92ff47232881831ac57e227639b2b8aa --- /dev/null +++ b/approval/hr/pto-request-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "pto-request-workflow", + "workflow_id": "pto-request", + "title": "Pto Request Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "approval", + "secondary_use_cases": [], + "use_cases": [ + "approval" + ], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "pto-request", + "time-off", + "vacation", + "leave-management", + "manager-approval", + "accrual-balance" + ], + "description": "PTO request workflow with balance verification, manager approval, calendar blocking, and team coverage check before approval.", + "source_path": "hr/pto-request", + "repo_path": "approval/hr/pto-request-workflow" +} diff --git a/approval/hr/pto-request-workflow/workflow.fz b/approval/hr/pto-request-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e640f3fe764c621d23bc2417675ceb5778089335 --- /dev/null +++ b/approval/hr/pto-request-workflow/workflow.fz @@ -0,0 +1,51 @@ +Employee { # Employee +n1: circle label:"Start" +n2: rectangle label:"Select PTO dates" +n3: rectangle label:"Add request notes" +n4: rectangle label:"Receive decision notification" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> HRSystem.n6.handle(top) [label="Check balance"] +n3.handle(bottom) -> Manager.n11.handle(top) [label="Submit"] +n4.handle(right) -> n5.handle(left) +} +HRSystem { # HR System +n6: rectangle label:"Fetch PTO balance" +n7: diamond label:"Sufficient balance?" +n8: rectangle label:"Check blackout dates" +n9: diamond label:"Dates available?" +n10: rectangle label:"Show insufficient balance" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(bottom) -> n10.handle(top) [label="No"] +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> Employee.n3.handle(bottom) [label="Yes"] +n9.handle(bottom) -> Employee.n2.handle(bottom) [label="No - Blocked"] +n10.handle(top) -> Employee.n2.handle(bottom) [label="Select less"] +} +Manager { # Manager +n11: rectangle label:"Review PTO request" +n12: rectangle label:"Check team coverage" +n13: diamond label:"Approve request?" +n14: rectangle label:"Approve with comment" +n15: rectangle label:"Deny with reason" +n16: rectangle label:"Suggest alternate dates" +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Yes"] +n13.handle(bottom) -> n15.handle(top) [label="No"] +n13.handle(left) -> n16.handle(top) [label="Partial"] +n14.handle(bottom) -> Calendar.n17.handle(top) [label="Approved"] +n15.handle(top) -> Employee.n4.handle(bottom) [label="Denied"] +n16.handle(top) -> Employee.n2.handle(bottom) [label="Revise dates"] +} +Calendar { # Calendar System +n17: rectangle label:"Block dates on calendar" +n18: rectangle label:"Deduct PTO balance" +n19: rectangle label:"Send confirmation email" +n20: rectangle label:"Notify team members" +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(top) -> Employee.n4.handle(bottom) [label="Confirmed"] +} diff --git a/approval/hr/salary-increase-workflow/README.md b/approval/hr/salary-increase-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..87b7ad776468c43ce1d389119f66571fe01787b8 --- /dev/null +++ b/approval/hr/salary-increase-workflow/README.md @@ -0,0 +1,19 @@ +# Salary Increase Workflow + +Salary increase workflow with market analysis, comp ratio review, budget validation, tiered approval based on increase percentage, and payroll system update. + +**Template ID:** `salary-increase-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** approval +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [salary-increase, compensation, merit-raise, market-adjustment, budget-approval, comp-ratio] +**Source path:** `hr/salary-increase` +**Repo path:** `approval/hr/salary-increase-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/hr/salary-increase-workflow/metadata.json b/approval/hr/salary-increase-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..15b59ddc3b39b5751fb8135a4646c85310d897a2 --- /dev/null +++ b/approval/hr/salary-increase-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "salary-increase-workflow", + "workflow_id": "salary-increase", + "title": "Salary Increase Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "approval", + "secondary_use_cases": [], + "use_cases": [ + "approval" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "salary-increase", + "compensation", + "merit-raise", + "market-adjustment", + "budget-approval", + "comp-ratio" + ], + "description": "Salary increase workflow with market analysis, comp ratio review, budget validation, tiered approval based on increase percentage, and payroll system update.", + "source_path": "hr/salary-increase", + "repo_path": "approval/hr/salary-increase-workflow" +} diff --git a/approval/hr/salary-increase-workflow/workflow.fz b/approval/hr/salary-increase-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..573cd45516ee5c658df2740b26c0907ab4b64d6d --- /dev/null +++ b/approval/hr/salary-increase-workflow/workflow.fz @@ -0,0 +1,34 @@ +employee { # Employee + n1: circle label:"Start Salary Increase" + n4: rectangle label:"Make Salary Increase decision" + n7: rectangle label:"Continue Salary Increase process" + n10: circle label:"End Salary Increase" + n1.handle(bottom) -> manager.n2.handle(top) + n1.handle(bottom) -> hr_system.n3.handle(top) + n1.handle(right) -> n4.handle(left) + n1.handle(bottom) -> manager.n5.handle(top) + n1.handle(bottom) -> hr_system.n6.handle(top) + n1.handle(right) -> n7.handle(left) + n1.handle(bottom) -> manager.n8.handle(top) + n1.handle(bottom) -> hr_system.n9.handle(top) + n4.handle(right) -> n10.handle(left) + n7.handle(right) -> n10.handle(left) +} + +manager { # Manager + n2: rectangle label:"Receive Salary Increase request" + n5: rectangle label:"Update records for Salary Increase" + n8: rectangle label:"Continue Salary Increase process" + n8.handle(right) -> employee.n10.handle(bottom) + n5.handle(right) -> employee.n10.handle(bottom) + n2.handle(right) -> employee.n10.handle(bottom) +} + +hr_system { # Hr_System + n3: rectangle label:"Review Salary Increase details" + n6: rectangle label:"Continue Salary Increase process" + n9: rectangle label:"Continue Salary Increase process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n10.handle(bottom) + n3.handle(right) -> employee.n10.handle(bottom) +} diff --git a/approval/hr/termination-process-workflow/README.md b/approval/hr/termination-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7e3f4133ab015ae94e6f91a001e68ab1950091a5 --- /dev/null +++ b/approval/hr/termination-process-workflow/README.md @@ -0,0 +1,19 @@ +# Termination Process Workflow + +Employee termination workflow handling voluntary and involuntary separations with legal review, separation agreements, final pay calculation, COBRA notices, and severance processing. + +**Template ID:** `termination-process-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** approval +**Secondary use cases:** offboarding +**Complexity:** 4/5 +**Nodes:** 20 +**Lanes:** 3 +**Tags:** [employee-termination, offboarding, separation-agreement, final-pay, cobra, severance, legal-review] +**Source path:** `hr/termination-process` +**Repo path:** `approval/hr/termination-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/hr/termination-process-workflow/metadata.json b/approval/hr/termination-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..cce7c45ab0efc56501a7082d90d69151613e40f9 --- /dev/null +++ b/approval/hr/termination-process-workflow/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "termination-process-workflow", + "workflow_id": "termination-process", + "title": "Termination Process Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "approval", + "secondary_use_cases": [ + "offboarding" + ], + "use_cases": [ + "approval", + "offboarding" + ], + "complexity": 4, + "num_nodes": 20, + "num_lanes": 3, + "tags": [ + "employee-termination", + "offboarding", + "separation-agreement", + "final-pay", + "cobra", + "severance", + "legal-review" + ], + "description": "Employee termination workflow handling voluntary and involuntary separations with legal review, separation agreements, final pay calculation, COBRA notices, and severance processing.", + "source_path": "hr/termination-process", + "repo_path": "approval/hr/termination-process-workflow" +} diff --git a/approval/hr/termination-process-workflow/workflow.fz b/approval/hr/termination-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c39c2c29cb22ccece833513805116c35338ce709 --- /dev/null +++ b/approval/hr/termination-process-workflow/workflow.fz @@ -0,0 +1,48 @@ +Manager { # Manager +n1: circle label:"Start" +n2: rectangle label:"Initiate termination request" +n3: rectangle label:"Document performance issues" +n4: rectangle label:"Conduct final meeting" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> HR.n6.handle(top) [label="Request"] +n3.handle(bottom) -> HR.n10.handle(top) [label="Documentation"] +n4.handle(right) -> n5.handle(left) +} +HR { # Human Resources +n6: rectangle label:"Review termination request" +n7: diamond label:"Termination type?" +n8: rectangle label:"Verify cause documentation" +n9: rectangle label:"Process voluntary resignation" +n10: diamond label:"Legal review required?" +n11: rectangle label:"Route to legal counsel" +n12: rectangle label:"Prepare separation agreement" +n13: rectangle label:"Calculate final pay" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Involuntary"] +n7.handle(bottom) -> n9.handle(top) [label="Voluntary"] +n8.handle(right) -> n10.handle(left) +n9.handle(bottom) -> n13.handle(top) +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n12.handle(top) [label="No"] +n11.handle(right) -> n12.handle(top) +n12.handle(right) -> n13.handle(left) +n13.handle(bottom) -> Payroll.n14.handle(top) [label="Process"] +} +Payroll { # Payroll +n14: rectangle label:"Calculate accrued PTO" +n15: rectangle label:"Process final paycheck" +n16: rectangle label:"Generate COBRA notice" +n17: rectangle label:"Issue W-2 instructions" +n18: diamond label:"Severance applicable?" +n19: rectangle label:"Process severance payment" +n20: rectangle label:"Complete termination" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Yes"] +n18.handle(bottom) -> n20.handle(top) [label="No"] +n19.handle(right) -> n20.handle(top) +n20.handle(top) -> Manager.n4.handle(bottom) [label="Finalized"] +} diff --git a/approval/patterns/authorization-flow-workflow/README.md b/approval/patterns/authorization-flow-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..eeea5d31e43821a3b7b784da1f51d33ef5a937e3 --- /dev/null +++ b/approval/patterns/authorization-flow-workflow/README.md @@ -0,0 +1,19 @@ +# Authorization Flow Workflow + +This workflow models checking user permissions before actions run. + +**Template ID:** `authorization-flow-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** approval +**Secondary use cases:** security +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [authorization, flow, patterns] +**Source path:** `patterns/authorization-flow` +**Repo path:** `approval/patterns/authorization-flow-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/approval/patterns/authorization-flow-workflow/metadata.json b/approval/patterns/authorization-flow-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..442873284052b733639e34306bd87d26da447fe6 --- /dev/null +++ b/approval/patterns/authorization-flow-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "authorization-flow-workflow", + "workflow_id": "authorization-flow", + "title": "Authorization Flow Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "approval", + "secondary_use_cases": [ + "security" + ], + "use_cases": [ + "approval", + "security" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "authorization", + "flow", + "patterns" + ], + "description": "This workflow models checking user permissions before actions run.", + "source_path": "patterns/authorization-flow", + "repo_path": "approval/patterns/authorization-flow-workflow" +} diff --git a/approval/patterns/authorization-flow-workflow/workflow.fz b/approval/patterns/authorization-flow-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..099076d86f84e7746d1bc6e5c94ce160e3c06ed0 --- /dev/null +++ b/approval/patterns/authorization-flow-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Authorization Flow" + n4: rectangle label:"Execute Authorization Flow action" + n7: rectangle label:"Monitor Authorization Flow status" + n10: circle label:"End Authorization Flow" + n1.handle(bottom) -> app.n2.handle(top) + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) +} + +app { # App + n2: rectangle label:"Receive Authorization Flow event" + n5: rectangle label:"Record Authorization Flow outcome" + n8: rectangle label:"Monitor Authorization Flow status" + n2.handle(bottom) -> service.n3.handle(top) [label="Next"] + n5.handle(bottom) -> service.n6.handle(top) [label="Done"] + n8.handle(bottom) -> service.n9.handle(top) [label="Processed"] +} + +service { # Service + n3: diamond label:"Validate Authorization Flow conditions" + n6: rectangle label:"Monitor Authorization Flow status" + n9: rectangle label:"Monitor Authorization Flow status" + n9.handle(right) -> user.n10.handle(left) + n6.handle(right) -> user.n7.handle(left) + n3.handle(left) -> app.n2.handle(left) [label="Retry/Rejected"] + n3.handle(right) -> user.n4.handle(left) +} diff --git a/billing/business-operations/dunning-flow-workflow/README.md b/billing/business-operations/dunning-flow-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d3d2b9a84a044093ae58a57e9d35523a9e53b48f --- /dev/null +++ b/billing/business-operations/dunning-flow-workflow/README.md @@ -0,0 +1,19 @@ +# Dunning Flow Workflow + +Dunning collection workflow with escalating reminder emails, grace period management, account suspension, and payment recovery tracking. + +**Template ID:** `dunning-flow-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** billing +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [dunning-flow, collections, overdue-payment, payment-reminder, account-suspension, revenue-recovery] +**Source path:** `business-operations/dunning-flow` +**Repo path:** `billing/business-operations/dunning-flow-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/billing/business-operations/dunning-flow-workflow/metadata.json b/billing/business-operations/dunning-flow-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..92efb10cb5adf2d257239cd1d6b2b8bb81d5ca00 --- /dev/null +++ b/billing/business-operations/dunning-flow-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "dunning-flow-workflow", + "workflow_id": "dunning-flow", + "title": "Dunning Flow Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "billing", + "secondary_use_cases": [], + "use_cases": [ + "billing" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "dunning-flow", + "collections", + "overdue-payment", + "payment-reminder", + "account-suspension", + "revenue-recovery" + ], + "description": "Dunning collection workflow with escalating reminder emails, grace period management, account suspension, and payment recovery tracking.", + "source_path": "business-operations/dunning-flow", + "repo_path": "billing/business-operations/dunning-flow-workflow" +} diff --git a/billing/business-operations/dunning-flow-workflow/workflow.fz b/billing/business-operations/dunning-flow-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..09fbabbf395158779a16cefad5aeb1942f42b6db --- /dev/null +++ b/billing/business-operations/dunning-flow-workflow/workflow.fz @@ -0,0 +1,43 @@ +BillingSystem { # Billing System +n1: circle label:"Start" +n2: rectangle label:"Detect failed payment" +n3: rectangle label:"Log payment failure" +n4: diamond label:"First failure?" +n5: rectangle label:"Schedule retry in 24h" +n6: rectangle label:"Increment failure count" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="Yes"] +n4.handle(bottom) -> n6.handle(top) [label="No"] +n5.handle(bottom) -> PaymentRetry.n7.handle(top) [label="Queue"] +n6.handle(bottom) -> Notifications.n12.handle(top) [label="Escalate"] +} +PaymentRetry { # Payment Retry +n7: rectangle label:"Attempt payment retry" +n8: diamond label:"Payment successful?" +n9: rectangle label:"Update subscription status" +n10: rectangle label:"Mark retry failed" +n11: circle label:"End" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(bottom) -> Notifications.n12.handle(top) [label="Notify"] +} +Notifications { # Notifications +n12: rectangle label:"Send payment failed email" +n13: diamond label:"Max retries reached?" +n14: rectangle label:"Send final warning email" +n15: rectangle label:"Schedule next retry" +n16: rectangle label:"Suspend account" +n17: rectangle label:"Send suspension notice" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Yes"] +n13.handle(bottom) -> n15.handle(top) [label="No"] +n14.handle(right) -> n16.handle(left) +n15.handle(top) -> PaymentRetry.n7.handle(bottom) [label="Retry later"] +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> PaymentRetry.n11.handle(bottom) [label="Complete"] +loop [retry up to 4 times] n7 n8 n10 n12 n13 n15 +} \ No newline at end of file diff --git a/billing/business-operations/payment-failure-workflow/README.md b/billing/business-operations/payment-failure-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..88b4f2fcec428bc0ade7141dd3d7e19826334881 --- /dev/null +++ b/billing/business-operations/payment-failure-workflow/README.md @@ -0,0 +1,19 @@ +# Payment Failure Workflow + +Failed payment recovery workflow with smart retry scheduling, dunning email sequence, payment method update prompts, and involuntary churn prevention. + +**Template ID:** `payment-failure-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** billing +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [payment-failure, dunning, retry-logic, card-decline, revenue-recovery, stripe] +**Source path:** `business-operations/payment-failure` +**Repo path:** `billing/business-operations/payment-failure-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/billing/business-operations/payment-failure-workflow/metadata.json b/billing/business-operations/payment-failure-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e469f37acb8a1951885dcfcdf342b810b2a57bd0 --- /dev/null +++ b/billing/business-operations/payment-failure-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "payment-failure-workflow", + "workflow_id": "payment-failure", + "title": "Payment Failure Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "billing", + "secondary_use_cases": [], + "use_cases": [ + "billing" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "payment-failure", + "dunning", + "retry-logic", + "card-decline", + "revenue-recovery", + "stripe" + ], + "description": "Failed payment recovery workflow with smart retry scheduling, dunning email sequence, payment method update prompts, and involuntary churn prevention.", + "source_path": "business-operations/payment-failure", + "repo_path": "billing/business-operations/payment-failure-workflow" +} diff --git a/billing/business-operations/payment-failure-workflow/workflow.fz b/billing/business-operations/payment-failure-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..167d271bbd359c0ee93395ef743456637ed3794f --- /dev/null +++ b/billing/business-operations/payment-failure-workflow/workflow.fz @@ -0,0 +1,43 @@ +PaymentGateway { # Payment Gateway +n1: circle label:"Start" +n2: rectangle label:"Receive payment request" +n3: diamond label:"Card valid?" +n4: rectangle label:"Attempt charge" +n5: diamond label:"Charge successful?" +n6: rectangle label:"Return success response" +n7: rectangle label:"Log failure reason" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) [label="Yes"] +n3.handle(bottom) -> n7.handle(top) [label="No - Invalid"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) [label="Yes"] +n5.handle(bottom) -> RetryEngine.n8.handle(top) [label="No - Declined"] +n6.handle(bottom) -> App.n15.handle(top) [label="Confirmed"] +n7.handle(bottom) -> App.n16.handle(top) [label="Card error"] +} +RetryEngine { # Retry Engine +n8: diamond label:"Retries remaining?" +n9: rectangle label:"Wait with exponential backoff" +n10: rectangle label:"Retry payment" +n11: rectangle label:"Mark as failed" +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n11.handle(top) [label="No"] +n9.handle(right) -> n10.handle(left) +n10.handle(top) -> PaymentGateway.n4.handle(bottom) [label="Retry"] +n11.handle(bottom) -> App.n16.handle(top) [label="Max retries"] +loop [retry up to 3 times] n8 n9 n10 +} +App { # Application +n12: rectangle label:"Update order status" +n13: rectangle label:"Send confirmation email" +n14: circle label:"End" +n15: rectangle label:"Mark payment complete" +n16: rectangle label:"Notify customer of failure" +n17: rectangle label:"Offer alternative payment" +n15.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n14.handle(top) +} \ No newline at end of file diff --git a/billing/business-operations/plan-downgrade-workflow/README.md b/billing/business-operations/plan-downgrade-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..37c958327097dd91bdb1aab88d8fbd9b80dcbce8 --- /dev/null +++ b/billing/business-operations/plan-downgrade-workflow/README.md @@ -0,0 +1,19 @@ +# Plan Downgrade Workflow + +Subscription plan downgrade workflow with retention offer, feature restriction warning, data migration handling, and end-of-period scheduling. + +**Template ID:** `plan-downgrade-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** billing +**Secondary use cases:** delivery +**Complexity:** 3/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [plan-downgrade, retention, feature-restriction, data-migration, churn-prevention, billing] +**Source path:** `business-operations/plan-downgrade` +**Repo path:** `billing/business-operations/plan-downgrade-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/billing/business-operations/plan-downgrade-workflow/metadata.json b/billing/business-operations/plan-downgrade-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7e849c4c884343d3897ce2fc869b9c4128b03d66 --- /dev/null +++ b/billing/business-operations/plan-downgrade-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "plan-downgrade-workflow", + "workflow_id": "plan-downgrade", + "title": "Plan Downgrade Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "billing", + "secondary_use_cases": [ + "delivery" + ], + "use_cases": [ + "billing", + "delivery" + ], + "complexity": 3, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "plan-downgrade", + "retention", + "feature-restriction", + "data-migration", + "churn-prevention", + "billing" + ], + "description": "Subscription plan downgrade workflow with retention offer, feature restriction warning, data migration handling, and end-of-period scheduling.", + "source_path": "business-operations/plan-downgrade", + "repo_path": "billing/business-operations/plan-downgrade-workflow" +} diff --git a/billing/business-operations/plan-downgrade-workflow/workflow.fz b/billing/business-operations/plan-downgrade-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b016d9eaa609cb5b8ff9d7604fcde7baf3453079 --- /dev/null +++ b/billing/business-operations/plan-downgrade-workflow/workflow.fz @@ -0,0 +1,55 @@ +Customer { # Customer +n1: circle label:"Start" +n2: rectangle label:"Request plan downgrade" +n3: rectangle label:"Review feature changes" +n4: diamond label:"Confirm downgrade?" +n5: rectangle label:"Receive downgrade confirmation" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> RetentionFlow.n7.handle(top) [label="Process request"] +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n6.handle(left) [label="No - Keep plan"] +n4.handle(bottom) -> Billing.n14.handle(top) [label="Yes"] +n5.handle(right) -> n6.handle(left) +} +RetentionFlow { # Retention Flow +n7: rectangle label:"Check usage patterns" +n8: diamond label:"Heavy feature user?" +n9: rectangle label:"Offer discount to stay" +n10: rectangle label:"Show feature comparison" +n11: diamond label:"Accept offer?" +n12: rectangle label:"Apply retention discount" +n13: rectangle label:"Continue to downgrade" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(top) -> Customer.n3.handle(bottom) [label="Review"] +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(top) -> Customer.n6.handle(bottom) [label="Retained"] +n13.handle(top) -> Customer.n3.handle(bottom) [label="Proceed"] +} +Billing { # Billing System +n14: rectangle label:"Calculate credit balance" +n15: rectangle label:"Schedule plan change" +n16: diamond label:"Immediate or end of period?" +n17: rectangle label:"Apply immediately" +n18: rectangle label:"Queue for period end" +n19: rectangle label:"Issue prorated credit" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Immediate"] +n16.handle(bottom) -> n18.handle(top) [label="Period end"] +n17.handle(right) -> n19.handle(left) +n18.handle(bottom) -> Provisioning.n20.handle(top) [label="Scheduled"] +n19.handle(bottom) -> Provisioning.n20.handle(top) [label="Process"] +} +Provisioning { # Feature Provisioning +n20: rectangle label:"Disable premium features" +n21: rectangle label:"Update usage limits" +n22: rectangle label:"Send downgrade email" +n20.handle(right) -> n21.handle(left) +n21.handle(right) -> n22.handle(left) +n22.handle(top) -> Customer.n5.handle(bottom) [label="Complete"] +} \ No newline at end of file diff --git a/billing/business-operations/plan-upgrade-workflow/README.md b/billing/business-operations/plan-upgrade-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f2b6f819ab67f014d37f9b83eba21c56b849dbe8 --- /dev/null +++ b/billing/business-operations/plan-upgrade-workflow/README.md @@ -0,0 +1,19 @@ +# Plan Upgrade Workflow + +Subscription plan upgrade workflow with feature comparison, proration calculation, immediate feature unlock, and billing adjustment. + +**Template ID:** `plan-upgrade-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** billing +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [plan-upgrade, upsell, proration, feature-unlock, expansion-revenue, billing] +**Source path:** `business-operations/plan-upgrade` +**Repo path:** `billing/business-operations/plan-upgrade-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/billing/business-operations/plan-upgrade-workflow/metadata.json b/billing/business-operations/plan-upgrade-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..869aade484c039c4fd2fcf38659ee2ccdbd38d04 --- /dev/null +++ b/billing/business-operations/plan-upgrade-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "plan-upgrade-workflow", + "workflow_id": "plan-upgrade", + "title": "Plan Upgrade Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "billing", + "secondary_use_cases": [], + "use_cases": [ + "billing" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "plan-upgrade", + "upsell", + "proration", + "feature-unlock", + "expansion-revenue", + "billing" + ], + "description": "Subscription plan upgrade workflow with feature comparison, proration calculation, immediate feature unlock, and billing adjustment.", + "source_path": "business-operations/plan-upgrade", + "repo_path": "billing/business-operations/plan-upgrade-workflow" +} diff --git a/billing/business-operations/plan-upgrade-workflow/workflow.fz b/billing/business-operations/plan-upgrade-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c6617d62aa55b347b4aef7dff14f570bb6ced19a --- /dev/null +++ b/billing/business-operations/plan-upgrade-workflow/workflow.fz @@ -0,0 +1,59 @@ +Customer { # Customer + n1: circle label:"Start" + n2: rectangle label:"Select new plan tier" + n3: rectangle label:"Review price difference" + n4: rectangle label:"Enter payment details" + n5: rectangle label:"Receive upgrade confirmation" + n6: circle label:"End" + + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> PricingEngine.n7.handle(top) [label="Calculate"] + n3.handle(right) -> n4.handle(left) + n4.handle(bottom) -> Billing.n12.handle(top) [label="Process payment"] + n5.handle(right) -> n6.handle(left) +} + +PricingEngine { # Pricing Engine + n7: rectangle label:"Fetch current subscription" + n8: rectangle label:"Calculate prorated amount" + n9: diamond label:"Credit balance available?" + n10: rectangle label:"Apply credit to upgrade" + n11: rectangle label:"Show full price" + + n7.handle(right) -> n8.handle(left) + n8.handle(right) -> n9.handle(left) + n9.handle(right) -> n10.handle(left) [label="Yes"] + n9.handle(bottom) -> n11.handle(top) [label="No"] + n10.handle(top) -> Customer.n3.handle(bottom) [label="Price ready"] + n11.handle(top) -> Customer.n3.handle(bottom) [label="Price ready"] +} + +Billing { # Billing System + n12: rectangle label:"Validate payment method" + n13: diamond label:"Payment valid?" + n14: rectangle label:"Charge prorated amount" + n15: rectangle label:"Return payment error" + n16: diamond label:"Charge successful?" + n17: rectangle label:"Update subscription tier" + n18: rectangle label:"Log failed charge" + + n12.handle(right) -> n13.handle(left) + n13.handle(right) -> n14.handle(left) [label="Yes"] + n13.handle(bottom) -> n15.handle(top) [label="No"] + n14.handle(right) -> n16.handle(left) + n15.handle(top) -> Customer.n4.handle(bottom) [label="Try again"] + n16.handle(right) -> n17.handle(left) [label="Yes"] + n16.handle(bottom) -> n18.handle(top) [label="No"] + n17.handle(bottom) -> Provisioning.n19.handle(top) [label="Activate"] + n18.handle(top) -> Customer.n4.handle(bottom) [label="Retry"] +} + +Provisioning { # Feature Provisioning + n19: rectangle label:"Enable premium features" + n20: rectangle label:"Update usage limits" + n21: rectangle label:"Send upgrade email" + + n19.handle(right) -> n20.handle(left) + n20.handle(right) -> n21.handle(left) + n21.handle(top) -> Customer.n5.handle(bottom) [label="Complete"] +} \ No newline at end of file diff --git a/billing/business-operations/shopify-universal-commerce-protocol/README.md b/billing/business-operations/shopify-universal-commerce-protocol/README.md new file mode 100644 index 0000000000000000000000000000000000000000..02606f9c619dbdde2ee2c073187db7c781a388d8 --- /dev/null +++ b/billing/business-operations/shopify-universal-commerce-protocol/README.md @@ -0,0 +1,19 @@ +# Shopify Universal Commerce Protocol + +End-to-end agentic commerce workflow showing how an AI assistant (ChatGPT) orchestrates product search, checkout, and payment through Shopify's Universal Commerce Protocol (UCP) gateway, enabling conversational shopping experiences. + +**Template ID:** `shopify-universal-commerce-protocol` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** billing +**Secondary use cases:** agentic +**Complexity:** 4/5 +**Nodes:** 47 +**Lanes:** 5 +**Tags:** [shopify, ucp, universal-commerce-protocol, agentic-commerce, ai-shopping, chatgpt, e-commerce, checkout, payment] +**Source path:** `business-operations/shopify-universal-commerce-protocol` +**Repo path:** `billing/business-operations/shopify-universal-commerce-protocol` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/billing/business-operations/shopify-universal-commerce-protocol/metadata.json b/billing/business-operations/shopify-universal-commerce-protocol/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..214fc0e7003f5a10ebfb909b684038f5a4390637 --- /dev/null +++ b/billing/business-operations/shopify-universal-commerce-protocol/metadata.json @@ -0,0 +1,32 @@ +{ + "template_id": "shopify-universal-commerce-protocol", + "workflow_id": "shopify-universal-commerce-protocol", + "title": "Shopify Universal Commerce Protocol", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "billing", + "secondary_use_cases": [ + "agentic" + ], + "use_cases": [ + "billing", + "agentic" + ], + "complexity": 4, + "num_nodes": 47, + "num_lanes": 5, + "tags": [ + "shopify", + "ucp", + "universal-commerce-protocol", + "agentic-commerce", + "ai-shopping", + "chatgpt", + "e-commerce", + "checkout", + "payment" + ], + "description": "End-to-end agentic commerce workflow showing how an AI assistant (ChatGPT) orchestrates product search, checkout, and payment through Shopify's Universal Commerce Protocol (UCP) gateway, enabling conversational shopping experiences.", + "source_path": "business-operations/shopify-universal-commerce-protocol", + "repo_path": "billing/business-operations/shopify-universal-commerce-protocol" +} diff --git a/billing/business-operations/shopify-universal-commerce-protocol/workflow.fz b/billing/business-operations/shopify-universal-commerce-protocol/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9e146347246a038bea33b95a33281a16df4e09d6 --- /dev/null +++ b/billing/business-operations/shopify-universal-commerce-protocol/workflow.fz @@ -0,0 +1,107 @@ +HumanShopper { # Human Shopper + n1: circle label:"Start: open ChatGPT" + n2: rectangle label:"Ask for a product" + n14: rectangle label:"Review recommendations" + n15: rectangle label:"Choose a product" + n24: rectangle label:"Provide address & prefs" + n33: rectangle label:"Confirm payment" + n47: circle label:"Order confirmed" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> ChatGPTAssistant.n3.handle(left) [label="Product request"] + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> ChatGPTAssistant.n16.handle(left) [label="Selected product"] + n24.handle(right) -> ChatGPTAssistant.n25.handle(left) [label="Address & prefs"] + n33.handle(right) -> ChatGPTAssistant.n34.handle(left) [label="Payment confirmed"] +} + +ChatGPTAssistant { # ChatGPT AI Assistant + n3: rectangle label:"Receive request & interpret intent" + n4: rectangle label:"Build structured search query" + n5: rectangle label:"Search via UCP gateway" + n11: rectangle label:"Receive UCP offers" + n12: rectangle label:"Rank & present recommendations" + n13: rectangle label:"Send recommendations to shopper" + n16: rectangle label:"Receive product selection" + n17: rectangle label:"Create checkout session via UCP" + n21: rectangle label:"Receive required checkout fields" + n22: rectangle label:"Ask shopper for missing info" + n23: rectangle label:"(wait for shopper)" + n25: rectangle label:"Receive shopper info" + n26: rectangle label:"Submit buyer details via UCP" + n30: rectangle label:"Receive final order summary" + n31: rectangle label:"Ask shopper to confirm payment" + n32: rectangle label:"(wait for confirmation)" + n34: rectangle label:"Receive payment confirmation" + n35: rectangle label:"Send payment intent via UCP" + n44: rectangle label:"Receive final order status" + n45: rectangle label:"Display confirmation" + n46: rectangle label:"(notify shopper)" + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> n5.handle(left) + n5.handle(right) -> ShopifyUCPGateway.n6.handle(left) [label="Catalog search"] + n11.handle(right) -> n12.handle(left) + n12.handle(right) -> n13.handle(left) + n13.handle(left) -> HumanShopper.n14.handle(right) [label="Recommendations"] + n16.handle(right) -> n17.handle(left) + n17.handle(right) -> ShopifyUCPGateway.n18.handle(left) [label="Create checkout"] + n21.handle(right) -> n22.handle(left) + n22.handle(right) -> n23.handle(left) + n23.handle(left) -> HumanShopper.n24.handle(right) [label="Request address & prefs"] + n25.handle(right) -> n26.handle(left) + n26.handle(right) -> ShopifyUCPGateway.n27.handle(left) [label="Buyer details"] + n30.handle(right) -> n31.handle(left) + n31.handle(right) -> n32.handle(left) + n32.handle(left) -> HumanShopper.n33.handle(right) [label="Confirm payment?"] + n34.handle(right) -> n35.handle(left) + n35.handle(right) -> ShopifyUCPGateway.n36.handle(left) [label="Payment intent"] + n44.handle(right) -> n45.handle(left) + n45.handle(right) -> n46.handle(left) + n46.handle(left) -> HumanShopper.n47.handle(right) [label="Order confirmed"] +} + +ShopifyUCPGateway { # Shopify UCP Gateway + n6: rectangle label:"Normalize search request" + n7: rectangle label:"Query Shopify Store catalog" + n10: rectangle label:"Assemble & return UCP offers" + n18: rectangle label:"Create checkout session" + n19: rectangle label:"Initialize checkout with Store" + n20: rectangle label:"Return required fields" + n27: rectangle label:"Update checkout with buyer data" + n28: rectangle label:"Recalculate totals via Store" + n29: rectangle label:"Return order summary" + n36: rectangle label:"Forward payment authorization" + n38: rectangle label:"Receive payment result" + n39: rectangle label:"Create order in Store" + n42: rectangle label:"Receive order confirmation" + n43: rectangle label:"Return final order status" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> ShopifyStoreCatalog.n8.handle(left) [label="Catalog query"] + n10.handle(left) -> ChatGPTAssistant.n11.handle(right) [label="UCP offers"] + n18.handle(right) -> n19.handle(left) + n19.handle(right) -> n20.handle(left) + n20.handle(left) -> ChatGPTAssistant.n21.handle(right) [label="Required fields"] + n27.handle(right) -> n28.handle(left) + n28.handle(right) -> n29.handle(left) + n29.handle(left) -> ChatGPTAssistant.n30.handle(right) [label="Order summary"] + n36.handle(right) -> PaymentProcessor.n37.handle(left) [label="Authorize/capture"] + n38.handle(right) -> n39.handle(left) + n39.handle(right) -> ShopifyStoreCatalog.n40.handle(left) [label="Create order"] + n42.handle(right) -> n43.handle(left) + n43.handle(left) -> ChatGPTAssistant.n44.handle(right) [label="Order status"] +} + +ShopifyStoreCatalog { # Shopify Store & Catalog + n8: rectangle label:"Search catalog for products" + n9: rectangle label:"Return matching products" + n40: rectangle label:"Persist order" + n41: rectangle label:"Return order confirmation" + n8.handle(bottom) -> n9.handle(top) + n9.handle(left) -> ShopifyUCPGateway.n10.handle(right) [label="Matching products"] + n40.handle(bottom) -> n41.handle(top) + n41.handle(left) -> ShopifyUCPGateway.n42.handle(right) [label="Order confirmation"] +} + +PaymentProcessor { # Payment Processor + n37: rectangle label:"Authorize & capture payment" + n37.handle(left) -> ShopifyUCPGateway.n38.handle(right) [label="Payment result"] +} diff --git a/billing/business-operations/subscription-lifecycle-workflow/README.md b/billing/business-operations/subscription-lifecycle-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..252be33e9e82b2b884a1ab8b983ba08d27d4a908 --- /dev/null +++ b/billing/business-operations/subscription-lifecycle-workflow/README.md @@ -0,0 +1,19 @@ +# Subscription Lifecycle Workflow + +SaaS subscription lifecycle workflow with trial signup, conversion nurturing, payment processing, renewal management, and churn prevention campaigns. + +**Template ID:** `subscription-lifecycle-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** billing +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [subscription-lifecycle, saas, trial-conversion, renewal, churn-prevention, stripe] +**Source path:** `business-operations/subscription-lifecycle` +**Repo path:** `billing/business-operations/subscription-lifecycle-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/billing/business-operations/subscription-lifecycle-workflow/metadata.json b/billing/business-operations/subscription-lifecycle-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b29c50e1d6bf2c8bef98a4185dd26b9c49a81d9b --- /dev/null +++ b/billing/business-operations/subscription-lifecycle-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "subscription-lifecycle-workflow", + "workflow_id": "subscription-lifecycle", + "title": "Subscription Lifecycle Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "billing", + "secondary_use_cases": [], + "use_cases": [ + "billing" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "subscription-lifecycle", + "saas", + "trial-conversion", + "renewal", + "churn-prevention", + "stripe" + ], + "description": "SaaS subscription lifecycle workflow with trial signup, conversion nurturing, payment processing, renewal management, and churn prevention campaigns.", + "source_path": "business-operations/subscription-lifecycle", + "repo_path": "billing/business-operations/subscription-lifecycle-workflow" +} diff --git a/billing/business-operations/subscription-lifecycle-workflow/workflow.fz b/billing/business-operations/subscription-lifecycle-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..91b5877d8b05ab035c7de54826e82ea2aae4680c --- /dev/null +++ b/billing/business-operations/subscription-lifecycle-workflow/workflow.fz @@ -0,0 +1,53 @@ +Stripe { # Stripe Webhooks +n1: circle label:"Start" +n2: rectangle label:"Receive webhook event" +n3: diamond label:"Event type?" +n4: rectangle label:"Handle subscription.created" +n5: rectangle label:"Handle invoice.paid" +n6: rectangle label:"Handle subscription.canceled" +n7: rectangle label:"Handle invoice.payment_failed" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) [label="created"] +n3.handle(bottom) -> n5.handle(top) [label="paid"] +n3.handle(left) -> n6.handle(top) [label="canceled"] +n3.handle(top) -> n7.handle(top) [label="failed"] +n4.handle(bottom) -> Provisioning.n8.handle(top) [label="Provision"] +n5.handle(bottom) -> Provisioning.n12.handle(top) [label="Extend"] +n6.handle(bottom) -> Provisioning.n14.handle(top) [label="Revoke"] +n7.handle(bottom) -> Dunning.n17.handle(top) [label="Retry"] +} +Provisioning { # Account Provisioning +n8: rectangle label:"Create user account" +n9: rectangle label:"Assign plan features" +n10: rectangle label:"Send welcome email" +n11: circle label:"End" +n12: rectangle label:"Update billing period" +n13: rectangle label:"Send receipt email" +n14: rectangle label:"Disable premium features" +n15: rectangle label:"Archive user data" +n16: rectangle label:"Send cancellation email" +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n11.handle(top) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n11.handle(top) +} +Dunning { # Dunning Management +n17: rectangle label:"Log payment failure" +n18: diamond label:"Retry count?" +n19: rectangle label:"Schedule retry charge" +n20: rectangle label:"Send payment reminder" +n21: rectangle label:"Suspend account" +n22: rectangle label:"Send final notice" +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="< 3"] +n18.handle(bottom) -> n21.handle(top) [label=">= 3"] +n19.handle(right) -> n20.handle(left) +n20.handle(top) -> Provisioning.n11.handle(bottom) [label="Wait"] +n21.handle(right) -> n22.handle(left) +n22.handle(top) -> Provisioning.n11.handle(bottom) [label="Suspended"] +} \ No newline at end of file diff --git a/billing/hr/conflict-resolution-workflow/README.md b/billing/hr/conflict-resolution-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f1a8a51fa46d2788dc43bb7ec1e1c005bc8d9673 --- /dev/null +++ b/billing/hr/conflict-resolution-workflow/README.md @@ -0,0 +1,19 @@ +# Conflict Resolution Workflow + +Workplace conflict resolution workflow with complaint intake, HR investigation, mediation sessions, resolution documentation, and follow-up monitoring. + +**Template ID:** `conflict-resolution-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** billing +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [conflict-resolution, workplace-dispute, mediation, hr-investigation, employee-relations, grievance] +**Source path:** `hr/conflict-resolution` +**Repo path:** `billing/hr/conflict-resolution-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/billing/hr/conflict-resolution-workflow/metadata.json b/billing/hr/conflict-resolution-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c5d7736dbd120a3d2c54ae11b8131503544febcd --- /dev/null +++ b/billing/hr/conflict-resolution-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "conflict-resolution-workflow", + "workflow_id": "conflict-resolution", + "title": "Conflict Resolution Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "billing", + "secondary_use_cases": [], + "use_cases": [ + "billing" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "conflict-resolution", + "workplace-dispute", + "mediation", + "hr-investigation", + "employee-relations", + "grievance" + ], + "description": "Workplace conflict resolution workflow with complaint intake, HR investigation, mediation sessions, resolution documentation, and follow-up monitoring.", + "source_path": "hr/conflict-resolution", + "repo_path": "billing/hr/conflict-resolution-workflow" +} diff --git a/billing/hr/conflict-resolution-workflow/workflow.fz b/billing/hr/conflict-resolution-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ec36e78983df55c168d115d3a689931283e7ecef --- /dev/null +++ b/billing/hr/conflict-resolution-workflow/workflow.fz @@ -0,0 +1,28 @@ +employee { # Employee + n1: circle label:"Start Conflict Resolution" + n4: diamond label:"Make Conflict Resolution decision" + n7: rectangle label:"Continue Conflict Resolution process" + n10: circle label:"End Conflict Resolution" + n1.handle(bottom) -> manager.n2.handle(top) + n4.handle(bottom) -> manager.n5.handle(top) + n7.handle(bottom) -> manager.n8.handle(top) + n4.handle(right) -> hr_system.n3.handle(bottom) [label="Retry/Rejected"] +} + +manager { # Manager + n2: rectangle label:"Receive Conflict Resolution request" + n5: rectangle label:"Update records for Conflict Resolution" + n8: rectangle label:"Continue Conflict Resolution process" + n2.handle(bottom) -> hr_system.n3.handle(top) [label="Next"] + n5.handle(bottom) -> hr_system.n6.handle(top) [label="Done"] + n8.handle(bottom) -> hr_system.n9.handle(top) [label="Processed"] +} + +hr_system { # Hr_System + n3: rectangle label:"Review Conflict Resolution details" + n6: rectangle label:"Continue Conflict Resolution process" + n9: rectangle label:"Continue Conflict Resolution process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n7.handle(left) + n3.handle(right) -> employee.n4.handle(left) +} diff --git a/billing/logistics/returns-processing-workflow/README.md b/billing/logistics/returns-processing-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1eafa6ec2cfe0bd2de903af4ee12852cc101a075 --- /dev/null +++ b/billing/logistics/returns-processing-workflow/README.md @@ -0,0 +1,19 @@ +# Returns Processing Workflow + +Customer returns processing workflow with RMA generation, return receipt, quality inspection, disposition decision, and refund or exchange processing. + +**Template ID:** `returns-processing-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** billing +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [returns-processing, rma, refund, restocking, quality-inspection, reverse-logistics] +**Source path:** `logistics/returns-processing` +**Repo path:** `billing/logistics/returns-processing-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/billing/logistics/returns-processing-workflow/metadata.json b/billing/logistics/returns-processing-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..a3075a687dd8f6c93bed2e00d4f024776ba51db3 --- /dev/null +++ b/billing/logistics/returns-processing-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "returns-processing-workflow", + "workflow_id": "returns-processing", + "title": "Returns Processing Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "billing", + "secondary_use_cases": [], + "use_cases": [ + "billing" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "returns-processing", + "rma", + "refund", + "restocking", + "quality-inspection", + "reverse-logistics" + ], + "description": "Customer returns processing workflow with RMA generation, return receipt, quality inspection, disposition decision, and refund or exchange processing.", + "source_path": "logistics/returns-processing", + "repo_path": "billing/logistics/returns-processing-workflow" +} diff --git a/billing/logistics/returns-processing-workflow/workflow.fz b/billing/logistics/returns-processing-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9f57b0f9936d53c56b11a424bf760d1b7823ea8e --- /dev/null +++ b/billing/logistics/returns-processing-workflow/workflow.fz @@ -0,0 +1,55 @@ +Customer { # Customer +n1: circle label:"Start" +n2: rectangle label:"Request return authorization" +n3: rectangle label:"Ship item back" +n4: rectangle label:"Receive refund or replacement" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> CustomerService.n6.handle(top) [label="RMA request"] +n3.handle(bottom) -> Warehouse.n13.handle(top) [label="Package shipped"] +n4.handle(right) -> n5.handle(left) +} +CustomerService { # Customer Service +n6: rectangle label:"Verify order details" +n7: diamond label:"Within return window?" +n8: rectangle label:"Generate RMA number" +n9: rectangle label:"Deny return request" +n10: rectangle label:"Email return label" +n11: diamond label:"Prepaid return?" +n12: rectangle label:"Charge return shipping" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(bottom) -> n9.handle(top) [label="No"] +n8.handle(right) -> n11.handle(left) +n9.handle(top) -> Customer.n5.handle(bottom) [label="Denied"] +n11.handle(right) -> n10.handle(left) [label="Yes"] +n11.handle(bottom) -> n12.handle(top) [label="No"] +n10.handle(top) -> Customer.n3.handle(bottom) [label="Label sent"] +n12.handle(top) -> Customer.n3.handle(bottom) [label="Pay shipping"] +} +Warehouse { # Warehouse +n13: rectangle label:"Receive returned package" +n14: rectangle label:"Inspect item condition" +n15: diamond label:"Item condition?" +n16: rectangle label:"Return to inventory" +n17: rectangle label:"Process as defective" +n18: rectangle label:"Flag as damaged by customer" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Like new"] +n15.handle(bottom) -> n17.handle(top) [label="Defective"] +n15.handle(left) -> n18.handle(top) [label="Damaged"] +n16.handle(bottom) -> Refunds.n19.handle(top) [label="Full refund"] +n17.handle(bottom) -> Refunds.n19.handle(top) [label="Full refund"] +n18.handle(bottom) -> Refunds.n22.handle(top) [label="Partial refund"] +} +Refunds { # Refunds Processing +n19: rectangle label:"Calculate refund amount" +n20: rectangle label:"Process refund to payment method" +n21: rectangle label:"Update order status" +n22: rectangle label:"Apply restocking fee" +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(top) -> Customer.n4.handle(bottom) [label="Refund issued"] +n22.handle(right) -> n20.handle(top) +} diff --git a/compliance/business-operations/consent-management-workflow/README.md b/compliance/business-operations/consent-management-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..05ea2f4451787b20efa0b0244f222ab021c8f27d --- /dev/null +++ b/compliance/business-operations/consent-management-workflow/README.md @@ -0,0 +1,19 @@ +# Consent Management Workflow + +User consent management workflow with cookie banner, preference center, consent recording, downstream system sync, and audit trail. + +**Template ID:** `consent-management-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [consent-management, gdpr, cookie-consent, privacy-preferences, opt-in-opt-out, compliance] +**Source path:** `business-operations/consent-management` +**Repo path:** `compliance/business-operations/consent-management-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/business-operations/consent-management-workflow/metadata.json b/compliance/business-operations/consent-management-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9a6ed27edc0eeb4e6c717da89ff1c55b1a39bc56 --- /dev/null +++ b/compliance/business-operations/consent-management-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "consent-management-workflow", + "workflow_id": "consent-management", + "title": "Consent Management Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "consent-management", + "gdpr", + "cookie-consent", + "privacy-preferences", + "opt-in-opt-out", + "compliance" + ], + "description": "User consent management workflow with cookie banner, preference center, consent recording, downstream system sync, and audit trail.", + "source_path": "business-operations/consent-management", + "repo_path": "compliance/business-operations/consent-management-workflow" +} diff --git a/compliance/business-operations/consent-management-workflow/workflow.fz b/compliance/business-operations/consent-management-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..10c6a17cb8ef2420e1cc23e7ecce6666af0c1a06 --- /dev/null +++ b/compliance/business-operations/consent-management-workflow/workflow.fz @@ -0,0 +1,42 @@ +Visitor { # Visitor +n1: circle label:"Start" +n2: rectangle label:"Land on website" +n3: rectangle label:"View cookie banner" +n4: diamond label:"Accept all cookies?" +n5: rectangle label:"Customize preferences" +n6: rectangle label:"Browse with preferences" +n7: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> ConsentPlatform.n8.handle(top) [label="Check consent"] +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n6.handle(left) [label="Yes"] +n4.handle(bottom) -> n5.handle(top) [label="No"] +n5.handle(bottom) -> ConsentPlatform.n12.handle(top) [label="Save choices"] +n6.handle(right) -> n7.handle(left) +} +ConsentPlatform { # Consent Platform +n8: diamond label:"Prior consent exists?" +n9: rectangle label:"Load saved preferences" +n10: rectangle label:"Show cookie banner" +n11: rectangle label:"Store consent record" +n12: rectangle label:"Update preference record" +n13: rectangle label:"Sync with ad platforms" +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(top) -> Visitor.n6.handle(bottom) [label="Apply"] +n10.handle(top) -> Visitor.n3.handle(bottom) [label="Display"] +n11.handle(right) -> n13.handle(left) +n12.handle(right) -> n11.handle(left) +n13.handle(top) -> Visitor.n6.handle(bottom) [label="Ready"] +} +Analytics { # Analytics +n14: rectangle label:"Check consent for tracking" +n15: diamond label:"Analytics consent given?" +n16: rectangle label:"Initialize tracking scripts" +n17: rectangle label:"Run in privacy mode" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(top) -> Visitor.n6.handle(bottom) [label="Tracking active"] +n17.handle(top) -> Visitor.n6.handle(bottom) [label="Limited mode"] +} \ No newline at end of file diff --git a/compliance/business-operations/data-export-workflow/README.md b/compliance/business-operations/data-export-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4d604af9f390badc1258f9f009e9bf6fbbceb0e9 --- /dev/null +++ b/compliance/business-operations/data-export-workflow/README.md @@ -0,0 +1,19 @@ +# Data Export Workflow + +User data export workflow with export request, async job processing, data aggregation, secure file generation, and download link delivery. + +**Template ID:** `data-export-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [data-export, data-portability, gdpr, bulk-export, async-job, download-link] +**Source path:** `business-operations/data-export` +**Repo path:** `compliance/business-operations/data-export-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/business-operations/data-export-workflow/metadata.json b/compliance/business-operations/data-export-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..fcddf307996bc1dc602a40d8cf2b7d8aac57c707 --- /dev/null +++ b/compliance/business-operations/data-export-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "data-export-workflow", + "workflow_id": "data-export", + "title": "Data Export Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "data-export", + "data-portability", + "gdpr", + "bulk-export", + "async-job", + "download-link" + ], + "description": "User data export workflow with export request, async job processing, data aggregation, secure file generation, and download link delivery.", + "source_path": "business-operations/data-export", + "repo_path": "compliance/business-operations/data-export-workflow" +} diff --git a/compliance/business-operations/data-export-workflow/workflow.fz b/compliance/business-operations/data-export-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..2a0df912070991ab02dfa72a476a1cc1a4f27b46 --- /dev/null +++ b/compliance/business-operations/data-export-workflow/workflow.fz @@ -0,0 +1,41 @@ +User { # User + n1: circle label:"Start" + n2: rectangle label:"Request data export" + n3: rectangle label:"Verify identity" + n4: rectangle label:"Download export file" + n5: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> App.n6.handle(top) [label="Submit request"] + n3.handle(bottom) -> App.n9.handle(top) [label="Verified"] + n4.handle(right) -> n5.handle(left) +} +App { # Application + n6: rectangle label:"Validate request" + n7: rectangle label:"Send verification email" + n8: diamond label:"Identity confirmed?" + n9: rectangle label:"Queue export job" + n10: rectangle label:"Reject request" + n6.handle(right) -> n7.handle(left) + n7.handle(top) -> User.n3.handle(bottom) [label="Check email"] + n8.handle(right) -> n9.handle(left) [label="Yes"] + n8.handle(bottom) -> n10.handle(top) [label="No"] + n9.handle(bottom) -> ExportService.n11.handle(top) [label="Process"] + n10.handle(top) -> User.n5.handle(bottom) [label="Denied"] +} +ExportService { # Export Service + n11: rectangle label:"Gather data from all sources" + n12: rectangle label:"Compile user profile data" + n13: rectangle label:"Include activity history" + n14: rectangle label:"Package as ZIP archive" + n15: diamond label:"File size acceptable?" + n16: rectangle label:"Split into multiple files" + n17: rectangle label:"Generate download link" + n11.handle(right) -> n12.handle(left) + n12.handle(right) -> n13.handle(left) + n13.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> n17.handle(left) [label="Yes"] + n15.handle(bottom) -> n16.handle(top) [label="No"] + n16.handle(right) -> n17.handle(top) + n17.handle(top) -> User.n4.handle(bottom) [label="Ready"] +} \ No newline at end of file diff --git a/compliance/business-operations/gdpr-deletion-workflow/README.md b/compliance/business-operations/gdpr-deletion-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..611ad42fb0abc0bde3068b903b37dfd39c35c8c2 --- /dev/null +++ b/compliance/business-operations/gdpr-deletion-workflow/README.md @@ -0,0 +1,19 @@ +# Gdpr Deletion Workflow + +GDPR data deletion workflow with identity verification, data inventory scan, PII removal across systems, backup purging, and deletion confirmation. + +**Template ID:** `gdpr-deletion-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [gdpr-deletion, right-to-be-forgotten, data-privacy, pii-removal, compliance, dsar] +**Source path:** `business-operations/gdpr-deletion` +**Repo path:** `compliance/business-operations/gdpr-deletion-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/business-operations/gdpr-deletion-workflow/metadata.json b/compliance/business-operations/gdpr-deletion-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..00882d49079fbbb68372fc6bc1f2185f23145d9e --- /dev/null +++ b/compliance/business-operations/gdpr-deletion-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "gdpr-deletion-workflow", + "workflow_id": "gdpr-deletion", + "title": "Gdpr Deletion Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "gdpr-deletion", + "right-to-be-forgotten", + "data-privacy", + "pii-removal", + "compliance", + "dsar" + ], + "description": "GDPR data deletion workflow with identity verification, data inventory scan, PII removal across systems, backup purging, and deletion confirmation.", + "source_path": "business-operations/gdpr-deletion", + "repo_path": "compliance/business-operations/gdpr-deletion-workflow" +} diff --git a/compliance/business-operations/gdpr-deletion-workflow/workflow.fz b/compliance/business-operations/gdpr-deletion-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d426f72a7c0534dae64384b1bd1e9d0c0fe542b6 --- /dev/null +++ b/compliance/business-operations/gdpr-deletion-workflow/workflow.fz @@ -0,0 +1,41 @@ +DataSubject { # Data Subject + n1: circle label:"Start" + n2: rectangle label:"Submit erasure request" + n3: rectangle label:"Verify identity via email" + n4: rectangle label:"Receive confirmation" + n5: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> DPO.n6.handle(top) [label="Request received"] + n3.handle(bottom) -> DPO.n9.handle(top) [label="Identity confirmed"] + n4.handle(right) -> n5.handle(left) +} +DPO { # Data Protection Officer + n6: rectangle label:"Log request in register" + n7: rectangle label:"Send identity verification" + n8: diamond label:"Identity verified?" + n9: rectangle label:"Approve deletion request" + n10: rectangle label:"Reject with explanation" + n6.handle(right) -> n7.handle(left) + n7.handle(top) -> DataSubject.n3.handle(bottom) [label="Verify"] + n8.handle(right) -> n9.handle(left) [label="Yes"] + n8.handle(bottom) -> n10.handle(top) [label="No"] + n9.handle(bottom) -> DataSystems.n11.handle(top) [label="Execute"] + n10.handle(top) -> DataSubject.n4.handle(bottom) [label="Denied"] +} +DataSystems { # Data Systems + n11: rectangle label:"Query all data stores" + n12: rectangle label:"Delete from primary database" + n13: rectangle label:"Remove from analytics" + n14: rectangle label:"Purge from backups" + n15: diamond label:"Third-party data shared?" + n16: rectangle label:"Send deletion requests to partners" + n17: rectangle label:"Generate deletion certificate" + n11.handle(right) -> n12.handle(left) + n12.handle(right) -> n13.handle(left) + n13.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> n16.handle(left) [label="Yes"] + n15.handle(bottom) -> n17.handle(top) [label="No"] + n16.handle(bottom) -> n17.handle(left) + n17.handle(top) -> DataSubject.n4.handle(bottom) [label="Complete"] +} \ No newline at end of file diff --git a/compliance/finance/financial-reporting-workflow/README.md b/compliance/finance/financial-reporting-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..af9d701f4ebe702276ccf0d2079ef782b05fafec --- /dev/null +++ b/compliance/finance/financial-reporting-workflow/README.md @@ -0,0 +1,19 @@ +# Financial Reporting Workflow + +Financial reporting workflow with GAAP-compliant statement preparation, management review, audit committee approval, and SEC filing for public companies. + +**Template ID:** `financial-reporting-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [financial-reporting, gaap-compliance, income-statement, balance-sheet, cash-flow-statement, sec-filing] +**Source path:** `finance/financial-reporting` +**Repo path:** `compliance/finance/financial-reporting-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/finance/financial-reporting-workflow/metadata.json b/compliance/finance/financial-reporting-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..96dc5fb6cfe125a91380fb11ff494ac80f41375b --- /dev/null +++ b/compliance/finance/financial-reporting-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "financial-reporting-workflow", + "workflow_id": "financial-reporting", + "title": "Financial Reporting Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "financial-reporting", + "gaap-compliance", + "income-statement", + "balance-sheet", + "cash-flow-statement", + "sec-filing" + ], + "description": "Financial reporting workflow with GAAP-compliant statement preparation, management review, audit committee approval, and SEC filing for public companies.", + "source_path": "finance/financial-reporting", + "repo_path": "compliance/finance/financial-reporting-workflow" +} diff --git a/compliance/finance/financial-reporting-workflow/workflow.fz b/compliance/finance/financial-reporting-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d63631829efd5ea7ba85d2d269f6bb330e876de5 --- /dev/null +++ b/compliance/finance/financial-reporting-workflow/workflow.fz @@ -0,0 +1,28 @@ +employee { # Employee + n1: circle label:"Start Financial Reporting" + n4: rectangle label:"Make Financial Reporting decision" + n7: rectangle label:"Continue Financial Reporting process" + n10: circle label:"End Financial Reporting" + n1.handle(bottom) -> manager.n2.handle(top) + n4.handle(bottom) -> manager.n5.handle(top) + n7.handle(bottom) -> manager.n8.handle(top) +} + +manager { # Manager + n2: rectangle label:"Receive Financial Reporting request" + n5: rectangle label:"Update records for Financial Reporting" + n8: rectangle label:"Continue Financial Reporting process" + n2.handle(bottom) -> finance_app.n3.handle(top) [label="Next"] + n5.handle(bottom) -> finance_app.n6.handle(top) [label="Done"] + n8.handle(bottom) -> finance_app.n9.handle(top) [label="Processed"] +} + +finance_app { # Finance_App + n3: rectangle label:"Review Financial Reporting details" + n6: diamond label:"Continue Financial Reporting process" + n9: rectangle label:"Continue Financial Reporting process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n7.handle(left) + n6.handle(left) -> manager.n5.handle(left) [label="Retry/Rejected"] + n3.handle(right) -> employee.n4.handle(left) +} diff --git a/compliance/finance/internal-controls-workflow/README.md b/compliance/finance/internal-controls-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..82be9ea669533654bba9bdecf0a5634301edb83a --- /dev/null +++ b/compliance/finance/internal-controls-workflow/README.md @@ -0,0 +1,19 @@ +# Internal Controls Workflow + +Internal controls testing workflow with risk assessment, control design evaluation, operating effectiveness testing, deficiency identification, and remediation tracking. + +**Template ID:** `internal-controls-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [internal-controls, sox-compliance, control-testing, segregation-of-duties, risk-assessment, remediation] +**Source path:** `finance/internal-controls` +**Repo path:** `compliance/finance/internal-controls-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/finance/internal-controls-workflow/metadata.json b/compliance/finance/internal-controls-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..5b977c54579903c731bfe3457b046a9ab0ae96b4 --- /dev/null +++ b/compliance/finance/internal-controls-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "internal-controls-workflow", + "workflow_id": "internal-controls", + "title": "Internal Controls Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "internal-controls", + "sox-compliance", + "control-testing", + "segregation-of-duties", + "risk-assessment", + "remediation" + ], + "description": "Internal controls testing workflow with risk assessment, control design evaluation, operating effectiveness testing, deficiency identification, and remediation tracking.", + "source_path": "finance/internal-controls", + "repo_path": "compliance/finance/internal-controls-workflow" +} diff --git a/compliance/finance/internal-controls-workflow/workflow.fz b/compliance/finance/internal-controls-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0f2aa0aa0b7e70214aa6230a2520542eb770cb5b --- /dev/null +++ b/compliance/finance/internal-controls-workflow/workflow.fz @@ -0,0 +1,34 @@ +employee { # Employee + n1: circle label:"Start Internal Controls" + n4: rectangle label:"Make Internal Controls decision" + n7: rectangle label:"Continue Internal Controls process" + n10: circle label:"End Internal Controls" + n1.handle(bottom) -> manager.n2.handle(top) + n1.handle(bottom) -> finance_app.n3.handle(top) + n1.handle(right) -> n4.handle(left) + n1.handle(bottom) -> manager.n5.handle(top) + n1.handle(bottom) -> finance_app.n6.handle(top) + n1.handle(right) -> n7.handle(left) + n1.handle(bottom) -> manager.n8.handle(top) + n1.handle(bottom) -> finance_app.n9.handle(top) + n7.handle(right) -> n10.handle(left) + n4.handle(top) -> n10.handle(top) +} + +manager { # Manager + n2: rectangle label:"Receive Internal Controls request" + n5: rectangle label:"Update records for Internal Controls" + n8: diamond label:"Continue Internal Controls process" + n5.handle(right) -> employee.n10.handle(bottom) + n8.handle(right) -> employee.n10.handle(bottom) + n2.handle(right) -> employee.n10.handle(bottom) +} + +finance_app { # Finance_App + n3: rectangle label:"Review Internal Controls details" + n6: rectangle label:"Continue Internal Controls process" + n9: rectangle label:"Continue Internal Controls process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n10.handle(bottom) + n3.handle(right) -> employee.n10.handle(bottom) +} diff --git a/compliance/finance/payroll-processing-workflow/README.md b/compliance/finance/payroll-processing-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a030cdf8d5bb339771c4c0f2c288fda18ea044b8 --- /dev/null +++ b/compliance/finance/payroll-processing-workflow/README.md @@ -0,0 +1,19 @@ +# Payroll Processing Workflow + +Complete payroll processing workflow with timesheet collection, gross pay calculation, overtime, tax withholding (federal, state, FICA), benefits deductions, compliance validation, and ACH direct deposit. + +**Template ID:** `payroll-processing-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 5/5 +**Nodes:** 24 +**Lanes:** 4 +**Tags:** [payroll-processing, salary-calculation, tax-withholding, fica, ach-direct-deposit, benefits-deductions, compliance] +**Source path:** `finance/payroll-processing` +**Repo path:** `compliance/finance/payroll-processing-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/finance/payroll-processing-workflow/metadata.json b/compliance/finance/payroll-processing-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..0f74eac72086b20b1f133fa992993f12b6d9f38d --- /dev/null +++ b/compliance/finance/payroll-processing-workflow/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "payroll-processing-workflow", + "workflow_id": "payroll-processing", + "title": "Payroll Processing Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 5, + "num_nodes": 24, + "num_lanes": 4, + "tags": [ + "payroll-processing", + "salary-calculation", + "tax-withholding", + "fica", + "ach-direct-deposit", + "benefits-deductions", + "compliance" + ], + "description": "Complete payroll processing workflow with timesheet collection, gross pay calculation, overtime, tax withholding (federal, state, FICA), benefits deductions, compliance validation, and ACH direct deposit.", + "source_path": "finance/payroll-processing", + "repo_path": "compliance/finance/payroll-processing-workflow" +} diff --git a/compliance/finance/payroll-processing-workflow/workflow.fz b/compliance/finance/payroll-processing-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..74e2a8077cbacfdca21d652b5db659a2ac736c22 --- /dev/null +++ b/compliance/finance/payroll-processing-workflow/workflow.fz @@ -0,0 +1,57 @@ +HRSystem { # HR System +n1: circle label:"Start" +n2: rectangle label:"Collect timesheet data" +n3: rectangle label:"Import attendance records" +n4: rectangle label:"Calculate gross pay" +n5: rectangle label:"Finalize payroll" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> PayrollEngine.n7.handle(top) [label="Process"] +n4.handle(bottom) -> Compliance.n14.handle(top) [label="Validate"] +n5.handle(right) -> n6.handle(left) +} +PayrollEngine { # Payroll Engine +n7: rectangle label:"Apply pay rates" +n8: rectangle label:"Calculate overtime" +n9: rectangle label:"Add bonuses and commissions" +n10: rectangle label:"Process deductions" +n11: diamond label:"Deductions valid?" +n12: rectangle label:"Calculate net pay" +n13: rectangle label:"Flag for review" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(top) -> HRSystem.n4.handle(bottom) [label="Calculated"] +n13.handle(top) -> HRSystem.n4.handle(bottom) [label="Review needed"] +} +Compliance { # Compliance +n14: rectangle label:"Withhold federal taxes" +n15: rectangle label:"Withhold state taxes" +n16: rectangle label:"Calculate FICA" +n17: rectangle label:"Process benefits deductions" +n18: diamond label:"Compliance check passed?" +n19: rectangle label:"Generate pay stubs" +n20: rectangle label:"Flag compliance issue" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Yes"] +n18.handle(bottom) -> n20.handle(top) [label="No"] +n19.handle(bottom) -> Banking.n21.handle(top) [label="Disburse"] +n20.handle(top) -> HRSystem.n4.handle(bottom) [label="Fix required"] +} +Banking { # Banking +n21: rectangle label:"Create ACH batch file" +n22: rectangle label:"Submit to bank" +n23: rectangle label:"Confirm transfers" +n24: rectangle label:"Update payroll records" +n21.handle(right) -> n22.handle(left) +n22.handle(right) -> n23.handle(left) +n23.handle(right) -> n24.handle(left) +n24.handle(top) -> HRSystem.n5.handle(bottom) [label="Complete"] +} diff --git a/compliance/finance/tax-filing-workflow/README.md b/compliance/finance/tax-filing-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9a2329ac680b962462ce6064309e36439d8cdfe --- /dev/null +++ b/compliance/finance/tax-filing-workflow/README.md @@ -0,0 +1,19 @@ +# Tax Filing Workflow + +Corporate tax filing workflow with taxable income calculation, deductions, tax credits, variance review, and electronic or paper filing to IRS with receipt confirmation. + +**Template ID:** `tax-filing-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 3 +**Tags:** [tax-filing, corporate-tax, tax-calculation, irs-efile, tax-credits, deductions, compliance] +**Source path:** `finance/tax-filing` +**Repo path:** `compliance/finance/tax-filing-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/finance/tax-filing-workflow/metadata.json b/compliance/finance/tax-filing-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e0359aff7286ba02d7e0929500df97c4e680de87 --- /dev/null +++ b/compliance/finance/tax-filing-workflow/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "tax-filing-workflow", + "workflow_id": "tax-filing", + "title": "Tax Filing Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 3, + "tags": [ + "tax-filing", + "corporate-tax", + "tax-calculation", + "irs-efile", + "tax-credits", + "deductions", + "compliance" + ], + "description": "Corporate tax filing workflow with taxable income calculation, deductions, tax credits, variance review, and electronic or paper filing to IRS with receipt confirmation.", + "source_path": "finance/tax-filing", + "repo_path": "compliance/finance/tax-filing-workflow" +} diff --git a/compliance/finance/tax-filing-workflow/workflow.fz b/compliance/finance/tax-filing-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..dc3f3faeb8cb31a50e27d8948fdbec6227774342 --- /dev/null +++ b/compliance/finance/tax-filing-workflow/workflow.fz @@ -0,0 +1,46 @@ +TaxTeam { # Tax Team +n1: circle label:"Start" +n2: rectangle label:"Gather financial data" +n3: rectangle label:"Prepare tax schedules" +n4: rectangle label:"Submit filing" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Calculation.n6.handle(top) [label="Calculate"] +n4.handle(right) -> n5.handle(left) +} +Calculation { # Tax Calculation +n6: rectangle label:"Calculate taxable income" +n7: rectangle label:"Apply deductions" +n8: rectangle label:"Compute tax liability" +n9: diamond label:"Tax credits applicable?" +n10: rectangle label:"Apply tax credits" +n11: rectangle label:"Calculate final amount" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n11.handle(top) [label="No"] +n10.handle(right) -> n11.handle(top) +n11.handle(bottom) -> Review.n12.handle(top) [label="Review"] +} +Review { # Tax Review +n12: rectangle label:"Review calculations" +n13: diamond label:"Discrepancies found?" +n14: rectangle label:"Investigate variances" +n15: rectangle label:"Prepare filing documents" +n16: diamond label:"Filing type?" +n17: rectangle label:"E-file with IRS" +n18: rectangle label:"Mail paper return" +n19: rectangle label:"Confirm receipt" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n15.handle(left) [label="No"] +n13.handle(bottom) -> n14.handle(top) [label="Yes"] +n14.handle(top) -> Calculation.n6.handle(bottom) [label="Recalculate"] +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Electronic"] +n16.handle(bottom) -> n18.handle(top) [label="Paper"] +n17.handle(right) -> n19.handle(left) +n18.handle(right) -> n19.handle(top) +n19.handle(top) -> TaxTeam.n4.handle(bottom) [label="Filed"] +} diff --git a/compliance/finance/yearly-audit-workflow/README.md b/compliance/finance/yearly-audit-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dd57517f418bff98652beb36a69e41ba10cbe965 --- /dev/null +++ b/compliance/finance/yearly-audit-workflow/README.md @@ -0,0 +1,19 @@ +# Yearly Audit Workflow + +Annual financial audit workflow with external auditor engagement, document preparation, fieldwork coordination, findings remediation, and management letter response. + +**Template ID:** `yearly-audit-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [annual-audit, external-auditors, sox-compliance, financial-statements, audit-findings, management-letter] +**Source path:** `finance/yearly-audit` +**Repo path:** `compliance/finance/yearly-audit-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/finance/yearly-audit-workflow/metadata.json b/compliance/finance/yearly-audit-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ed2fa00c59105188b258ee446846fcf6bef8615c --- /dev/null +++ b/compliance/finance/yearly-audit-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "yearly-audit-workflow", + "workflow_id": "yearly-audit", + "title": "Yearly Audit Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "annual-audit", + "external-auditors", + "sox-compliance", + "financial-statements", + "audit-findings", + "management-letter" + ], + "description": "Annual financial audit workflow with external auditor engagement, document preparation, fieldwork coordination, findings remediation, and management letter response.", + "source_path": "finance/yearly-audit", + "repo_path": "compliance/finance/yearly-audit-workflow" +} diff --git a/compliance/finance/yearly-audit-workflow/workflow.fz b/compliance/finance/yearly-audit-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..855194a66eba22f3917a92a333a763e668c9c3a4 --- /dev/null +++ b/compliance/finance/yearly-audit-workflow/workflow.fz @@ -0,0 +1,28 @@ +employee { # Employee + n1: circle label:"Start Yearly Audit" + n4: rectangle label:"Make Yearly Audit decision" + n7: diamond label:"Continue Yearly Audit process" + n10: circle label:"End Yearly Audit" + n1.handle(bottom) -> manager.n2.handle(top) + n4.handle(bottom) -> manager.n5.handle(top) + n7.handle(bottom) -> manager.n8.handle(top) + n7.handle(right) -> finance_app.n6.handle(right) [label="Retry/Rejected"] +} + +manager { # Manager + n2: rectangle label:"Receive Yearly Audit request" + n5: rectangle label:"Update records for Yearly Audit" + n8: rectangle label:"Continue Yearly Audit process" + n2.handle(bottom) -> finance_app.n3.handle(top) + n5.handle(bottom) -> finance_app.n6.handle(top) + n8.handle(bottom) -> finance_app.n9.handle(top) +} + +finance_app { # Finance_App + n3: rectangle label:"Review Yearly Audit details" + n6: rectangle label:"Continue Yearly Audit process" + n9: rectangle label:"Continue Yearly Audit process" + n6.handle(bottom) -> employee.n7.handle(top) [label="Success"] + n9.handle(right) -> employee.n10.handle(bottom) [label="Valid"] + n3.handle(right) -> employee.n4.handle(left) [label="Processed"] +} diff --git a/compliance/hr/training-enrollment-workflow/README.md b/compliance/hr/training-enrollment-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b7352f8e25d21a629e7adea9e874a16e755b105f --- /dev/null +++ b/compliance/hr/training-enrollment-workflow/README.md @@ -0,0 +1,19 @@ +# Training Enrollment Workflow + +Training enrollment workflow with course catalog browsing, manager approval, LMS registration, completion tracking, and certification management. + +**Template ID:** `training-enrollment-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [training-enrollment, learning-management, lms, professional-development, compliance-training, certification] +**Source path:** `hr/training-enrollment` +**Repo path:** `compliance/hr/training-enrollment-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/hr/training-enrollment-workflow/metadata.json b/compliance/hr/training-enrollment-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..30a0340381ea820cf2eb470d80723f9fd4c3ebc0 --- /dev/null +++ b/compliance/hr/training-enrollment-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "training-enrollment-workflow", + "workflow_id": "training-enrollment", + "title": "Training Enrollment Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "training-enrollment", + "learning-management", + "lms", + "professional-development", + "compliance-training", + "certification" + ], + "description": "Training enrollment workflow with course catalog browsing, manager approval, LMS registration, completion tracking, and certification management.", + "source_path": "hr/training-enrollment", + "repo_path": "compliance/hr/training-enrollment-workflow" +} diff --git a/compliance/hr/training-enrollment-workflow/workflow.fz b/compliance/hr/training-enrollment-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9f6817a2a58faa7455a4e89933bdf873b684f97a --- /dev/null +++ b/compliance/hr/training-enrollment-workflow/workflow.fz @@ -0,0 +1,18 @@ +employee { # Employee + n1: circle label:"Start Training Enrollment" + n3: rectangle label:"Review Training Enrollment details" + n5: rectangle label:"Update records for Training Enrollment" + n7: circle label:"End Training Enrollment" + n1.handle(bottom) -> manager.n2.handle(top) [label="Success"] + n3.handle(bottom) -> manager.n4.handle(top) + n5.handle(bottom) -> manager.n6.handle(top) +} + +manager { # Manager + n2: rectangle label:"Receive Training Enrollment request" + n4: rectangle label:"Make Training Enrollment decision" + n6: rectangle label:"Continue Training Enrollment process" + n6.handle(right) -> employee.n7.handle(bottom) + n4.handle(right) -> employee.n5.handle(left) [label="Valid"] + n2.handle(right) -> employee.n3.handle(left) +} diff --git a/compliance/logistics/cycle-counting-workflow/README.md b/compliance/logistics/cycle-counting-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..376421c0df0b4b28a84cf53b612ee9dd5dcb6f0e --- /dev/null +++ b/compliance/logistics/cycle-counting-workflow/README.md @@ -0,0 +1,19 @@ +# Cycle Counting Workflow + +Inventory cycle counting workflow with ABC classification, count scheduling, variance investigation, adjustment approval, and inventory accuracy tracking. + +**Template ID:** `cycle-counting-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [cycle-counting, inventory-accuracy, abc-analysis, variance-investigation, perpetual-inventory, audit] +**Source path:** `logistics/cycle-counting` +**Repo path:** `compliance/logistics/cycle-counting-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/logistics/cycle-counting-workflow/metadata.json b/compliance/logistics/cycle-counting-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..341da9b42a289a82feb1ec40ce2b7deadf9da53a --- /dev/null +++ b/compliance/logistics/cycle-counting-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "cycle-counting-workflow", + "workflow_id": "cycle-counting", + "title": "Cycle Counting Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "cycle-counting", + "inventory-accuracy", + "abc-analysis", + "variance-investigation", + "perpetual-inventory", + "audit" + ], + "description": "Inventory cycle counting workflow with ABC classification, count scheduling, variance investigation, adjustment approval, and inventory accuracy tracking.", + "source_path": "logistics/cycle-counting", + "repo_path": "compliance/logistics/cycle-counting-workflow" +} diff --git a/compliance/logistics/cycle-counting-workflow/workflow.fz b/compliance/logistics/cycle-counting-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..4f5692e93cde05502d73268aaead753a452f30b7 --- /dev/null +++ b/compliance/logistics/cycle-counting-workflow/workflow.fz @@ -0,0 +1,34 @@ +supplier { # Supplier + n1: circle label:"Start Cycle Counting" + n4: rectangle label:"Make Cycle Counting decision" + n7: rectangle label:"Continue Cycle Counting process" + n10: circle label:"End Cycle Counting" + n1.handle(bottom) -> warehouse.n2.handle(top) + n1.handle(bottom) -> iot_sensor.n3.handle(top) + n1.handle(right) -> n4.handle(left) + n1.handle(bottom) -> warehouse.n5.handle(top) + n1.handle(bottom) -> iot_sensor.n6.handle(top) + n1.handle(right) -> n7.handle(left) + n1.handle(bottom) -> warehouse.n8.handle(top) + n1.handle(bottom) -> iot_sensor.n9.handle(top) + n7.handle(right) -> n10.handle(left) + n4.handle(top) -> n10.handle(top) +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Cycle Counting request" + n5: rectangle label:"Update records for Cycle Counting" + n8: rectangle label:"Continue Cycle Counting process" + n8.handle(right) -> supplier.n10.handle(bottom) + n5.handle(right) -> supplier.n10.handle(bottom) + n2.handle(right) -> supplier.n10.handle(bottom) +} + +iot_sensor { # Iot_Sensor + n3: rectangle label:"Review Cycle Counting details" + n6: rectangle label:"Continue Cycle Counting process" + n9: rectangle label:"Continue Cycle Counting process" + n9.handle(right) -> supplier.n10.handle(bottom) + n6.handle(right) -> supplier.n10.handle(bottom) + n3.handle(right) -> supplier.n10.handle(bottom) +} diff --git a/compliance/logistics/fleet-maintenance-workflow/README.md b/compliance/logistics/fleet-maintenance-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..14658f3f7b06ac865913ff8dde7e478afc3e2806 --- /dev/null +++ b/compliance/logistics/fleet-maintenance-workflow/README.md @@ -0,0 +1,19 @@ +# Fleet Maintenance Workflow + +Fleet maintenance workflow with preventive maintenance scheduling, vehicle inspection, work order creation, parts ordering, and DOT compliance tracking. + +**Template ID:** `fleet-maintenance-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [fleet-maintenance, preventive-maintenance, vehicle-inspection, work-order, dot-compliance, telematics] +**Source path:** `logistics/fleet-maintenance` +**Repo path:** `compliance/logistics/fleet-maintenance-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/logistics/fleet-maintenance-workflow/metadata.json b/compliance/logistics/fleet-maintenance-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..70deac150df6f7b10dc5ed00b7c418797f183da9 --- /dev/null +++ b/compliance/logistics/fleet-maintenance-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "fleet-maintenance-workflow", + "workflow_id": "fleet-maintenance", + "title": "Fleet Maintenance Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "fleet-maintenance", + "preventive-maintenance", + "vehicle-inspection", + "work-order", + "dot-compliance", + "telematics" + ], + "description": "Fleet maintenance workflow with preventive maintenance scheduling, vehicle inspection, work order creation, parts ordering, and DOT compliance tracking.", + "source_path": "logistics/fleet-maintenance", + "repo_path": "compliance/logistics/fleet-maintenance-workflow" +} diff --git a/compliance/logistics/fleet-maintenance-workflow/workflow.fz b/compliance/logistics/fleet-maintenance-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..eb97055ff47445bf03072f78e28a1b0179ef6f07 --- /dev/null +++ b/compliance/logistics/fleet-maintenance-workflow/workflow.fz @@ -0,0 +1,20 @@ +supplier { # Supplier + n1: circle label:"Start Fleet Maintenance" + n2: diamond label:"Receive Fleet Maintenance request" + n3: rectangle label:"Review Fleet Maintenance details" + n5: rectangle label:"Update records for Fleet Maintenance" + n7: circle label:"End Fleet Maintenance" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> warehouse.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> warehouse.n6.handle(top) + loop [retry until success] n2 n3 n5 n4 n6 +} + +warehouse { # Warehouse + n4: rectangle label:"Make Fleet Maintenance decision" + n6: rectangle label:"Continue Fleet Maintenance process" + n6.handle(right) -> supplier.n7.handle(bottom) + n4.handle(right) -> supplier.n5.handle(top) +} diff --git a/compliance/patterns/audit-trail-workflow/README.md b/compliance/patterns/audit-trail-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..117757223bb4371d055b7746e5c1e14d9aea3200 --- /dev/null +++ b/compliance/patterns/audit-trail-workflow/README.md @@ -0,0 +1,19 @@ +# Audit Trail Workflow + +This workflow models logging all important actions for compliance. + +**Template ID:** `audit-trail-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [audit, trail, patterns, decision, loop] +**Source path:** `patterns/audit-trail` +**Repo path:** `compliance/patterns/audit-trail-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/patterns/audit-trail-workflow/metadata.json b/compliance/patterns/audit-trail-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..fce506768c5f7e1057861c0be783c0de2d309e5d --- /dev/null +++ b/compliance/patterns/audit-trail-workflow/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "audit-trail-workflow", + "workflow_id": "audit-trail", + "title": "Audit Trail Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "audit", + "trail", + "patterns", + "decision", + "loop" + ], + "description": "This workflow models logging all important actions for compliance.", + "source_path": "patterns/audit-trail", + "repo_path": "compliance/patterns/audit-trail-workflow" +} diff --git a/compliance/patterns/audit-trail-workflow/workflow.fz b/compliance/patterns/audit-trail-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..923ad425c0056d53d9bf5b962c14367ae9f37cbd --- /dev/null +++ b/compliance/patterns/audit-trail-workflow/workflow.fz @@ -0,0 +1,37 @@ +user { # User + n1: circle label:"Start Audit Trail" + n2: diamond label:"Receive Audit Trail event" + n5: rectangle label:"Record Audit Trail outcome" + n9: rectangle label:"Monitor Audit Trail status" + n13: circle label:"End Audit Trail" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] + n2.handle(bottom) -> database.n4.handle(top) [label="No/Rejected"] + n5.handle(bottom) -> app.n6.handle(top) + n9.handle(bottom) -> app.n10.handle(top) +} + +app { # App + n6: rectangle label:"Monitor Audit Trail status" + n10: rectangle label:"Monitor Audit Trail status" + n6.handle(bottom) -> service.n7.handle(top) + n10.handle(bottom) -> service.n11.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Audit Trail conditions" + n7: rectangle label:"Monitor Audit Trail status" + n11: rectangle label:"Monitor Audit Trail status" + n7.handle(bottom) -> database.n8.handle(top) + n11.handle(bottom) -> database.n12.handle(top) + n3.handle(right) -> user.n5.handle(left) +} + +database { # Database + n4: rectangle label:"Execute Audit Trail action" + n8: rectangle label:"Monitor Audit Trail status" + n12: rectangle label:"Monitor Audit Trail status" + n12.handle(right) -> user.n13.handle(bottom) + n8.handle(right) -> user.n9.handle(left) + n4.handle(right) -> user.n5.handle(bottom) +} diff --git a/compliance/patterns/event-sourcing-workflow/README.md b/compliance/patterns/event-sourcing-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..677dde27dd6afc733db2327e05aa6437a8dbbe9f --- /dev/null +++ b/compliance/patterns/event-sourcing-workflow/README.md @@ -0,0 +1,19 @@ +# Event Sourcing Workflow + +Event sourcing pattern with event capture, event store persistence, aggregate reconstruction, snapshot optimization, and temporal state queries. + +**Template ID:** `event-sourcing-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** compliance +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [event-sourcing, event-store, aggregate, replay, audit-log, temporal-query] +**Source path:** `patterns/event-sourcing` +**Repo path:** `compliance/patterns/event-sourcing-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/compliance/patterns/event-sourcing-workflow/metadata.json b/compliance/patterns/event-sourcing-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..791a0f08a624376347601119e941e6bcf58ad628 --- /dev/null +++ b/compliance/patterns/event-sourcing-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "event-sourcing-workflow", + "workflow_id": "event-sourcing", + "title": "Event Sourcing Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "compliance", + "secondary_use_cases": [], + "use_cases": [ + "compliance" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "event-sourcing", + "event-store", + "aggregate", + "replay", + "audit-log", + "temporal-query" + ], + "description": "Event sourcing pattern with event capture, event store persistence, aggregate reconstruction, snapshot optimization, and temporal state queries.", + "source_path": "patterns/event-sourcing", + "repo_path": "compliance/patterns/event-sourcing-workflow" +} diff --git a/compliance/patterns/event-sourcing-workflow/workflow.fz b/compliance/patterns/event-sourcing-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..4b4dff26bc1c319ffc15f76409e03857ac779ba2 --- /dev/null +++ b/compliance/patterns/event-sourcing-workflow/workflow.fz @@ -0,0 +1,43 @@ +Command { # Command Handler +n1: circle label:"Start" +n2: rectangle label:"Receive command" +n3: rectangle label:"Validate command" +n4: rectangle label:"Query current state" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> EventStore.n6.handle(top) [label="Process"] +n4.handle(right) -> n5.handle(left) +} +EventStore { # Event Store +n6: rectangle label:"Load aggregate events" +n7: rectangle label:"Replay to build state" +n8: diamond label:"Command valid for state?" +n9: rectangle label:"Create new event" +n10: rectangle label:"Reject command" +n11: rectangle label:"Append to event stream" +n12: rectangle label:"Publish to subscribers" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(top) -> Command.n4.handle(bottom) [label="Invalid"] +n11.handle(right) -> n12.handle(left) +n12.handle(bottom) -> Projection.n13.handle(top) [label="Notify"] +} +Projection { # Read Model Projection +n13: rectangle label:"Receive event notification" +n14: rectangle label:"Update read model" +n15: diamond label:"Projection type?" +n16: rectangle label:"Update SQL database" +n17: rectangle label:"Update search index" +n18: rectangle label:"Acknowledge processing" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Database"] +n15.handle(bottom) -> n17.handle(top) [label="Search"] +n16.handle(right) -> n18.handle(left) +n17.handle(right) -> n18.handle(top) +n18.handle(top) -> Command.n4.handle(bottom) [label="Complete"] +} diff --git a/context-management/architecture/context-episodic-memory/README.md b/context-management/architecture/context-episodic-memory/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3bf4c62df63130f796608af0e1d2f95715e71668 --- /dev/null +++ b/context-management/architecture/context-episodic-memory/README.md @@ -0,0 +1,19 @@ +# Context Management - Episodic Memory + +Learning-from-experience pattern where every task run becomes an episode with input, actions, and outcome. Before tackling a new task, the agent fetches similar episodes and uses them as hints. Over time, the agent feels like it's learning instead of repeating the same failed plans. + +**Template ID:** `context-episodic-memory` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** context-management +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 11 +**Lanes:** 4 +**Tags:** [context-management, episodic-memory, learning, experience, architecture-diagram] +**Source path:** `` +**Repo path:** `context-management/architecture/context-episodic-memory` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/context-management/architecture/context-episodic-memory/metadata.json b/context-management/architecture/context-episodic-memory/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3cdd2f3eaf3c9471062c0523abf63b6a7b533113 --- /dev/null +++ b/context-management/architecture/context-episodic-memory/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "context-episodic-memory", + "workflow_id": "context-episodic-memory", + "title": "Context Management - Episodic Memory", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "context-management", + "secondary_use_cases": [], + "use_cases": [ + "context-management" + ], + "complexity": 3, + "num_nodes": 11, + "num_lanes": 4, + "tags": [ + "context-management", + "episodic-memory", + "learning", + "experience", + "architecture-diagram" + ], + "description": "Learning-from-experience pattern where every task run becomes an episode with input, actions, and outcome. Before tackling a new task, the agent fetches similar episodes and uses them as hints. Over time, the agent feels like it's learning instead of repeating the same failed plans.", + "source_path": "", + "repo_path": "context-management/architecture/context-episodic-memory" +} diff --git a/context-management/architecture/context-episodic-memory/workflow.fz b/context-management/architecture/context-episodic-memory/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6d91fdb7f6f6e79de0000349b55534ba6cdac252 --- /dev/null +++ b/context-management/architecture/context-episodic-memory/workflow.fz @@ -0,0 +1,38 @@ +User { + n1: circle label="1. Submit task" + n2: rectangle label="12. See result" + n1.handle(right) -> Agent.n3.handle(left) + Agent.n9.handle(right) -> n2.handle(left) +} + +Agent { + n3: rectangle label="1. Receive task" + n4: rectangle label="2. Search similar episodes" + n5: rectangle label="4. Past lessons" + n6: rectangle label="5. Execute plan" + n7: rectangle label="6. Capture outcome" + n8: rectangle label="7. Send episode for scoring" + n9: rectangle label="11. Return result" + n3.handle(right) -> n4.handle(left) + n5.handle(right) -> n6.handle(left) + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n8.handle(right) -> Evaluator.n13.handle(left) [label="8. Outcome"] + EpisodeStore.n12.handle(right) -> n9.handle(left) [label="11.b Outcome"] +} + +EpisodeStore { + n10: rectangle label="3. Episode search" + n11: rectangle label="3.2 Search similar episodes" + n12: rectangle label="10. Episode + lesson" + Agent.n4.handle(right) -> n10.handle(left) [label="2. Search similar episodes"] + n10.handle(right) -> n11.handle(left) [label="3. Episode search"] + n11.handle(right) -> Agent.n5.handle(left) [label="4. Past lessons"] + Evaluator.n14.handle(right) -> n12.handle(left) [label="10. Episode + lesson"] +} + +Evaluator { + n13: rectangle label="9. Score outcome" + n14: rectangle label="9. Extract lesson" + n13.handle(right) -> n14.handle(left) +} diff --git a/context-management/architecture/context-hybrid-retrieval-memory/README.md b/context-management/architecture/context-hybrid-retrieval-memory/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2eeb4a58452a85fcca181f6e34b975e8b222efdc --- /dev/null +++ b/context-management/architecture/context-hybrid-retrieval-memory/README.md @@ -0,0 +1,19 @@ +# Context Management - Hybrid Retrieval Memory + +Multi-modal retrieval pattern combining semantic search, exact/keyword search, and recency search in parallel. Results are merged and reranked into a single context set. Much higher recall because the agent can find both fuzzy references and exact entities. Essential for comprehensive knowledge retrieval. + +**Template ID:** `context-hybrid-retrieval-memory` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** context-management +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 11 +**Lanes:** 5 +**Tags:** [context-management, hybrid-retrieval, semantic, keyword, recency, architecture-diagram] +**Source path:** `` +**Repo path:** `context-management/architecture/context-hybrid-retrieval-memory` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/context-management/architecture/context-hybrid-retrieval-memory/metadata.json b/context-management/architecture/context-hybrid-retrieval-memory/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..010033e4fab1e45f8cbb0d371a9d1969c312fc9a --- /dev/null +++ b/context-management/architecture/context-hybrid-retrieval-memory/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "context-hybrid-retrieval-memory", + "workflow_id": "context-hybrid-retrieval-memory", + "title": "Context Management - Hybrid Retrieval Memory", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "context-management", + "secondary_use_cases": [], + "use_cases": [ + "context-management" + ], + "complexity": 4, + "num_nodes": 11, + "num_lanes": 5, + "tags": [ + "context-management", + "hybrid-retrieval", + "semantic", + "keyword", + "recency", + "architecture-diagram" + ], + "description": "Multi-modal retrieval pattern combining semantic search, exact/keyword search, and recency search in parallel. Results are merged and reranked into a single context set. Much higher recall because the agent can find both fuzzy references and exact entities. Essential for comprehensive knowledge retrieval.", + "source_path": "", + "repo_path": "context-management/architecture/context-hybrid-retrieval-memory" +} diff --git a/context-management/architecture/context-hybrid-retrieval-memory/workflow.fz b/context-management/architecture/context-hybrid-retrieval-memory/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..43570e7723eb47aeb3825d7d352f6fd26119a657 --- /dev/null +++ b/context-management/architecture/context-hybrid-retrieval-memory/workflow.fz @@ -0,0 +1,52 @@ +User { + n1: circle label="Ask mixed query" + n2: rectangle label="See answer" + n1.handle(right) -> Agent.n3.handle(left) + Agent.n18.handle(right) -> n2.handle(left) +} + +Agent { + n3: rectangle label="Plan retrieval strategy" + n4: rectangle label="Trigger semantic search" + n5: rectangle label="Trigger keyword search" + n6: rectangle label="Trigger recent-history search" + n7: rectangle label="Merge and rerank" + n8: rectangle label="Build prompt with hybrid context" + n9: rectangle label="Call LLM" + n18: rectangle label="Return answer" + n3.handle(bottom) -> n4.handle(top) [label="Semantic"] + n3.handle(right) -> n5.handle(left) [label="Keyword"] + n3.handle(left) -> n6.handle(right) [label="Recent"] + n7.handle(right) -> n8.handle(left) + n8.handle(right) -> n9.handle(left) + n9.handle(right) -> LLM.n19.handle(left) +} + +Semantic { + n10: rectangle label="Vector search" + n11: rectangle label="Return semantic matches" + Agent.n4.handle(right) -> n10.handle(left) + n10.handle(right) -> n11.handle(left) + n11.handle(bottom) -> Agent.n7.handle(top) [label="Semantic"] +} + +Keyword { + n12: rectangle label="Exact/ID search" + n13: rectangle label="Return exact matches" + Agent.n5.handle(right) -> n12.handle(left) + n12.handle(right) -> n13.handle(left) + n13.handle(bottom) -> Agent.n7.handle(top) [label="Keyword"] +} + +Recent { + n14: rectangle label="Scan recent messages" + n15: rectangle label="Return recent matches" + Agent.n6.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) + n15.handle(bottom) -> Agent.n7.handle(top) [label="Recent"] +} + +LLM { + n19: rectangle label="Reason over hybrid context" + n19.handle(right) -> Agent.n18.handle(left) +} diff --git a/context-management/architecture/context-profile-memory/README.md b/context-management/architecture/context-profile-memory/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6cb7c88638ee7f6589ee1c175295af6574294359 --- /dev/null +++ b/context-management/architecture/context-profile-memory/README.md @@ -0,0 +1,19 @@ +# Context Management - Profile Memory + +Identity-style memory pattern where profile data is loaded at session start. Each prompt combines system persona, user profile, and current message. New facts can be written back to profile memory. Small predictable overhead with big UX lift — the agent remembers your name, stack, tone, and constraints. + +**Template ID:** `context-profile-memory` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** context-management +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 3 +**Tags:** [context-management, profile-memory, identity, user-profile, architecture-diagram] +**Source path:** `` +**Repo path:** `context-management/architecture/context-profile-memory` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/context-management/architecture/context-profile-memory/metadata.json b/context-management/architecture/context-profile-memory/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..2d777bdc8c0b3a886242aab4430720b6690d55a0 --- /dev/null +++ b/context-management/architecture/context-profile-memory/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "context-profile-memory", + "workflow_id": "context-profile-memory", + "title": "Context Management - Profile Memory", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "context-management", + "secondary_use_cases": [], + "use_cases": [ + "context-management" + ], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 3, + "tags": [ + "context-management", + "profile-memory", + "identity", + "user-profile", + "architecture-diagram" + ], + "description": "Identity-style memory pattern where profile data is loaded at session start. Each prompt combines system persona, user profile, and current message. New facts can be written back to profile memory. Small predictable overhead with big UX lift — the agent remembers your name, stack, tone, and constraints.", + "source_path": "", + "repo_path": "context-management/architecture/context-profile-memory" +} diff --git a/context-management/architecture/context-profile-memory/workflow.fz b/context-management/architecture/context-profile-memory/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3ed133be2a9f7a69f222ddc147e9795b22a81169 --- /dev/null +++ b/context-management/architecture/context-profile-memory/workflow.fz @@ -0,0 +1,33 @@ +User { + n1: circle label="Start session" + n2: rectangle label="Send request" + n3: rectangle label="See personalized reply" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> Agent.n4.handle(left) + Agent.n9.handle(right) -> n3.handle(left) +} + +Agent { + n4: rectangle label="Identify user" + n5: rectangle label="Load profile" + n6: rectangle label="Build prompt with profile" + n7: rectangle label="Call LLM" + n8: rectangle label="Optionally update profile" + n9: rectangle label="Return answer" + n4.handle(right) -> n5.handle(left) + n5.handle(right) -> n6.handle(left) + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> LLM.n10.handle(left) + n8.handle(right) -> ProfileStore.n11.handle(left) [label="Write profile"] +} + +ProfileStore { + n11: rectangle label="Read/Write profile" + Agent.n5.handle(bottom) -> n11.handle(top) [label="Read profile"] + n11.handle(right) -> Agent.n5.handle(left) +} + +LLM { + n10: rectangle label="Generate answer using profile" + n10.handle(right) -> Agent.n9.handle(left) +} diff --git a/context-management/architecture/context-rolling-summary-memory/README.md b/context-management/architecture/context-rolling-summary-memory/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6845a6dc8d34ba11f7d4fe8997d5eaa8d1e82bdf --- /dev/null +++ b/context-management/architecture/context-rolling-summary-memory/README.md @@ -0,0 +1,19 @@ +# Context Management - Rolling Summary Memory + +Compressed history pattern that keeps full history for a while, then when a threshold is hit, summarizes the last chunk and replaces detailed turns with a shorter summary message. Dramatically reduces prompt size on long-running chats while maintaining gist continuity. + +**Template ID:** `context-rolling-summary-memory` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** context-management +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 8 +**Lanes:** 4 +**Tags:** [context-management, rolling-summary, compression, memory, architecture-diagram] +**Source path:** `` +**Repo path:** `context-management/architecture/context-rolling-summary-memory` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/context-management/architecture/context-rolling-summary-memory/metadata.json b/context-management/architecture/context-rolling-summary-memory/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..70aaa9ea50edacf4885d24584741385b1923069b --- /dev/null +++ b/context-management/architecture/context-rolling-summary-memory/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "context-rolling-summary-memory", + "workflow_id": "context-rolling-summary-memory", + "title": "Context Management - Rolling Summary Memory", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "context-management", + "secondary_use_cases": [], + "use_cases": [ + "context-management" + ], + "complexity": 3, + "num_nodes": 8, + "num_lanes": 4, + "tags": [ + "context-management", + "rolling-summary", + "compression", + "memory", + "architecture-diagram" + ], + "description": "Compressed history pattern that keeps full history for a while, then when a threshold is hit, summarizes the last chunk and replaces detailed turns with a shorter summary message. Dramatically reduces prompt size on long-running chats while maintaining gist continuity.", + "source_path": "", + "repo_path": "context-management/architecture/context-rolling-summary-memory" +} diff --git a/context-management/architecture/context-rolling-summary-memory/workflow.fz b/context-management/architecture/context-rolling-summary-memory/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..7e213ab3bea122a4e1702ac1e34d8e1cbabde344 --- /dev/null +++ b/context-management/architecture/context-rolling-summary-memory/workflow.fz @@ -0,0 +1,39 @@ +User { + n1: circle label="New message" + n2: rectangle label="See reply" + n1.handle(right) -> Agent.n3.handle(left) + Agent.n12.handle(right) -> n2.handle(left) +} + +Agent { + n3: rectangle label="Append turn to history" + n4: diamond label="Summary threshold reached?" + n5: rectangle label="Request latest summary" + n6: rectangle label="Build compact prompt" + n7: rectangle label="Call LLM" + n12: rectangle label="Return answer" + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> Summarizer.n8.handle(left) [label="Yes"] + n4.handle(bottom) -> n5.handle(top) [label="No"] + n5.handle(bottom) -> SummaryStore.n10.handle(top) [label="Load summary"] + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> LLM.n13.handle(left) +} + +Summarizer { + n8: rectangle label="Summarize recent turns" + n9: rectangle label="Store summary snapshot" + n8.handle(right) -> n9.handle(left) + n9.handle(bottom) -> SummaryStore.n11.handle(top) [label="Save summary"] +} + +SummaryStore { + n10: rectangle label="Read latest summary" + n11: rectangle label="Write summary" + n10.handle(right) -> Agent.n6.handle(left) +} + +LLM { + n13: rectangle label="Generate answer" + n13.handle(right) -> Agent.n12.handle(left) +} diff --git a/context-management/architecture/context-semantic-memory/README.md b/context-management/architecture/context-semantic-memory/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9d8a9da6b5639efb74398dc464f60323350a3bb7 --- /dev/null +++ b/context-management/architecture/context-semantic-memory/README.md @@ -0,0 +1,19 @@ +# Context Management - Semantic Memory + +Vector-based memory pattern where text is chunked, embedded, and stored in a vector database. On query, the question is embedded, a vector search is run, candidates are reranked, and top results are injected into the prompt. Where the agent feels like it remembers everything without hallucinating. + +**Template ID:** `context-semantic-memory` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** context-management +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 9 +**Lanes:** 4 +**Tags:** [context-management, semantic-memory, vector-db, embeddings, rag, architecture-diagram] +**Source path:** `` +**Repo path:** `context-management/architecture/context-semantic-memory` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/context-management/architecture/context-semantic-memory/metadata.json b/context-management/architecture/context-semantic-memory/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..67c0f3f760ed0bf0a8c2462fafca3a871172237b --- /dev/null +++ b/context-management/architecture/context-semantic-memory/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "context-semantic-memory", + "workflow_id": "context-semantic-memory", + "title": "Context Management - Semantic Memory", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "context-management", + "secondary_use_cases": [], + "use_cases": [ + "context-management" + ], + "complexity": 3, + "num_nodes": 9, + "num_lanes": 4, + "tags": [ + "context-management", + "semantic-memory", + "vector-db", + "embeddings", + "rag", + "architecture-diagram" + ], + "description": "Vector-based memory pattern where text is chunked, embedded, and stored in a vector database. On query, the question is embedded, a vector search is run, candidates are reranked, and top results are injected into the prompt. Where the agent feels like it remembers everything without hallucinating.", + "source_path": "", + "repo_path": "context-management/architecture/context-semantic-memory" +} diff --git a/context-management/architecture/context-semantic-memory/workflow.fz b/context-management/architecture/context-semantic-memory/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9d1b27413673f6d915d7e51838928081ae5f3be9 --- /dev/null +++ b/context-management/architecture/context-semantic-memory/workflow.fz @@ -0,0 +1,41 @@ +User { + n1: circle label="Ask question" + n2: rectangle label="See answer with references" + n1.handle(right) -> Agent.n3.handle(left) + Agent.n12.handle(right) -> n2.handle(left) +} + +Agent { + n3: rectangle label="Receive query" + n4: rectangle label="Build memory search query" + n5: rectangle label="Send to retriever" + n6: rectangle label="Inject recalled memories" + n7: rectangle label="Assemble final prompt" + n8: rectangle label="Call LLM" + n12: rectangle label="Return answer" + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> n5.handle(left) + n5.handle(bottom) -> Retriever.n9.handle(top) [label="Semantic query"] + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n8.handle(right) -> LLM.n13.handle(left) +} + +Retriever { + n9: rectangle label="Embed query" + n10: rectangle label="Search vector store" + n11: rectangle label="Rerank top memories" + n9.handle(right) -> n10.handle(left) + n10.handle(right) -> n11.handle(left) + n11.handle(top) -> Agent.n6.handle(bottom) [label="Top memories"] +} + +VectorDB { + n13: rectangle label="Vector index" + Retriever.n10.handle(bottom) -> n13.handle(top) [label="Similarity search"] +} + +LLM { + n14: rectangle label="Answer using recalled facts" + n14.handle(right) -> Agent.n12.handle(left) +} diff --git a/context-management/architecture/context-session-memory/README.md b/context-management/architecture/context-session-memory/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0bcc0b5047bb2a0c21c91d6bba07c00c2ff11be4 --- /dev/null +++ b/context-management/architecture/context-session-memory/README.md @@ -0,0 +1,19 @@ +# Context Management - Session Memory + +Short-term context pattern where the channel sends new messages plus recent history. The agent runtime merges that with local session state, assembles the prompt, and persists the response back into history. Simple but cost and latency grow with history length. + +**Template ID:** `context-session-memory` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** context-management +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 9 +**Lanes:** 3 +**Tags:** [context-management, session-memory, short-term, memory, architecture-diagram] +**Source path:** `` +**Repo path:** `context-management/architecture/context-session-memory` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/context-management/architecture/context-session-memory/metadata.json b/context-management/architecture/context-session-memory/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9cbdf04b1f712be6e47ac97bf2a8824d8cc1058e --- /dev/null +++ b/context-management/architecture/context-session-memory/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "context-session-memory", + "workflow_id": "context-session-memory", + "title": "Context Management - Session Memory", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "context-management", + "secondary_use_cases": [], + "use_cases": [ + "context-management" + ], + "complexity": 2, + "num_nodes": 9, + "num_lanes": 3, + "tags": [ + "context-management", + "session-memory", + "short-term", + "memory", + "architecture-diagram" + ], + "description": "Short-term context pattern where the channel sends new messages plus recent history. The agent runtime merges that with local session state, assembles the prompt, and persists the response back into history. Simple but cost and latency grow with history length.", + "source_path": "", + "repo_path": "context-management/architecture/context-session-memory" +} diff --git a/context-management/architecture/context-session-memory/workflow.fz b/context-management/architecture/context-session-memory/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9f258cfb367c9bf892faae8f44a798820a925c47 --- /dev/null +++ b/context-management/architecture/context-session-memory/workflow.fz @@ -0,0 +1,39 @@ +User { # User +n1: circle label="User sends message" +n2: rectangle label="See agent reply" + +n1.handle(right) -> Agent.n3.handle(left) +Agent.n8.handle(right) -> n2.handle(left) +} + +Agent { # Agent +n3: rectangle label="Receive message" +n4: rectangle label="Load session history" +n5: rectangle label="Assemble prompt" +n6: rectangle label="Call LLM" +n7: rectangle label="Receive LLM reply" +n8: rectangle label="Return answer to user" +n9: rectangle label="Persist updated session" + +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> LLM.n10.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(bottom) -> n9.handle(top) [label="Save session"] +} + +Memory { # Session Store +n11: rectangle label="Read session state" +n12: rectangle label="Write session state" + +n3.handle(bottom) -> n11.handle(top) [label="Get history"] +n11.handle(right) -> Agent.n4.handle(left) +Agent.n9.handle(bottom) -> n12.handle(top) [label="Store history"] +} + +LLM { # LLM +n10: rectangle label="Generate answer" + +n10.handle(right) -> Agent.n7.handle(left) +} diff --git a/delivery/architecture/agentic-sequential-pipeline/README.md b/delivery/architecture/agentic-sequential-pipeline/README.md new file mode 100644 index 0000000000000000000000000000000000000000..217ad7f45de54c86b99134067219afcb3704ba2d --- /dev/null +++ b/delivery/architecture/agentic-sequential-pipeline/README.md @@ -0,0 +1,19 @@ +# Agentic Sequential Pipeline Architecture + +A sequential pipeline multi-agent architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. No central orchestrator — the flow is deterministic like an assembly line. + +**Template ID:** `agentic-sequential-pipeline` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** agentic, ai-orchestration +**Complexity:** 2/5 +**Nodes:** 5 +**Lanes:** 5 +**Tags:** [agentic, sequential-pipeline, multi-agent, assembly-line, architecture-diagram, ai-team] +**Source path:** `` +**Repo path:** `delivery/architecture/agentic-sequential-pipeline` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/agentic-sequential-pipeline/metadata.json b/delivery/architecture/agentic-sequential-pipeline/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6a1ae9333c3377825f377a6cf85cb4f975e14ce9 --- /dev/null +++ b/delivery/architecture/agentic-sequential-pipeline/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "agentic-sequential-pipeline", + "workflow_id": "agentic-sequential-pipeline", + "title": "Agentic Sequential Pipeline Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [ + "agentic", + "ai-orchestration" + ], + "use_cases": [ + "delivery", + "agentic", + "ai-orchestration" + ], + "complexity": 2, + "num_nodes": 5, + "num_lanes": 5, + "tags": [ + "agentic", + "sequential-pipeline", + "multi-agent", + "assembly-line", + "architecture-diagram", + "ai-team" + ], + "description": "A sequential pipeline multi-agent architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. No central orchestrator — the flow is deterministic like an assembly line.", + "source_path": "", + "repo_path": "delivery/architecture/agentic-sequential-pipeline" +} diff --git a/delivery/architecture/agentic-sequential-pipeline/workflow.fz b/delivery/architecture/agentic-sequential-pipeline/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6acd8083b44ab0e5c637a42556c0556d2d94ce2a --- /dev/null +++ b/delivery/architecture/agentic-sequential-pipeline/workflow.fz @@ -0,0 +1,23 @@ +research_agent {# Research Agent + n1: rectangle label="Summarize Sources (RAG)" + n1.handle(right) -> outline_agent.n2.handle(left) [label="Raw Sources"] +} + +outline_agent {# Outline Agent + n2: rectangle label="Structure Headings" + n2.handle(right) -> writer_agent.n3.handle(left) [label="Document Outline"] +} + +writer_agent {# Writer Agent + n3: rectangle label="Draft Full Text" + n3.handle(right) -> editor_agent.n4.handle(left) [label="First Draft"] +} + +editor_agent {# Editor Agent + n4: rectangle label="Refine Tone & Grammar" + n4.handle(right) -> seo_agent.n5.handle(left) [label="Refined Text"] +} + +seo_agent {# SEO Agent + n5: rectangle label="Add Keywords & Meta" +} diff --git a/delivery/architecture/ai-native-parallel-fan-out-architecture/README.md b/delivery/architecture/ai-native-parallel-fan-out-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d78005d875dfd79b2943c75fe7d38f91debf205b --- /dev/null +++ b/delivery/architecture/ai-native-parallel-fan-out-architecture/README.md @@ -0,0 +1,19 @@ +# AI-Native Parallel Fan-Out Architecture + +A parallel fan-out architecture that runs multiple agents simultaneously on independent checks (style, security, performance) and then merges results. This is a standard multi-agent design approach for throughput, mapping cleanly to CI/CD, incident response, and research. Fan-in reconciliation becomes the subtle part. + +**Template ID:** `ai-native-parallel-fan-out-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** agentic, ai-orchestration +**Complexity:** 3/5 +**Nodes:** 11 +**Lanes:** 2 +**Tags:** [ai-native, parallel-fan-out, agentic-ai, map-reduce, ci-cd, architecture-diagram] +**Source path:** `` +**Repo path:** `delivery/architecture/ai-native-parallel-fan-out-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/ai-native-parallel-fan-out-architecture/metadata.json b/delivery/architecture/ai-native-parallel-fan-out-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d313a75a27f77a84639aad282dcac1368d978582 --- /dev/null +++ b/delivery/architecture/ai-native-parallel-fan-out-architecture/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "ai-native-parallel-fan-out-architecture", + "workflow_id": "ai-native-parallel-fan-out-architecture", + "title": "AI-Native Parallel Fan-Out Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [ + "agentic", + "ai-orchestration" + ], + "use_cases": [ + "delivery", + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "num_nodes": 11, + "num_lanes": 2, + "tags": [ + "ai-native", + "parallel-fan-out", + "agentic-ai", + "map-reduce", + "ci-cd", + "architecture-diagram" + ], + "description": "A parallel fan-out architecture that runs multiple agents simultaneously on independent checks (style, security, performance) and then merges results. This is a standard multi-agent design approach for throughput, mapping cleanly to CI/CD, incident response, and research. Fan-in reconciliation becomes the subtle part.", + "source_path": "", + "repo_path": "delivery/architecture/ai-native-parallel-fan-out-architecture" +} diff --git a/delivery/architecture/ai-native-parallel-fan-out-architecture/workflow.fz b/delivery/architecture/ai-native-parallel-fan-out-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..cb7675fb535eaf553c116d56883f9e951c2b3122 --- /dev/null +++ b/delivery/architecture/ai-native-parallel-fan-out-architecture/workflow.fz @@ -0,0 +1,29 @@ +Trigger { # Trigger +n1: circle label:"Start" +n2: rectangle label:"PR submitted for review" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Coordinator.n3.handle(top) [label="PR payload"] +} +Coordinator { # Coordinator Agent +n3: rectangle label:"Fan out to reviewers" +n4: rectangle label:"Gather all reviews" +n5: diamond label:"All passed?" +n6: rectangle label:"Approve PR" +n7: rectangle label:"Request changes" +n8: circle label:"Done" +n3.handle(bottom) -> Reviewers.n9.handle(top) [label="Style check"] +n3.handle(bottom) -> Reviewers.n10.handle(top) [label="Security audit"] +n3.handle(bottom) -> Reviewers.n11.handle(top) [label="Perf analysis"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) [label="Yes"] +n5.handle(bottom) -> n7.handle(top) [label="No"] +n6.handle(right) -> n8.handle(left) +} +Reviewers { # Parallel Review Agents +n9: rectangle label:"Style Agent" +n10: rectangle label:"Security Agent" +n11: rectangle label:"Performance Agent" +n9.handle(top) -> Coordinator.n4.handle(bottom) [label="Style report"] +n10.handle(top) -> Coordinator.n4.handle(bottom) [label="Security report"] +n11.handle(top) -> Coordinator.n4.handle(bottom) [label="Perf report"] +} diff --git a/delivery/architecture/ai-native-sequential-pipeline-architecture/README.md b/delivery/architecture/ai-native-sequential-pipeline-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..56798957c191cfadafb15f3106bc638ab7caf358 --- /dev/null +++ b/delivery/architecture/ai-native-sequential-pipeline-architecture/README.md @@ -0,0 +1,19 @@ +# AI-Native Sequential Pipeline Architecture + +A sequential pipeline architecture chaining multiple agents in a fixed order (parse → enrich → analyze → format), which is a common 'LLM microservices' setup when each step can be isolated. This structure is often used in document processing and ETL-like workflows because each step is testable and predictable. + +**Template ID:** `ai-native-sequential-pipeline-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** agentic, ai-orchestration +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [ai-native, sequential-pipeline, agentic-ai, llm-microservices, architecture-diagram] +**Source path:** `` +**Repo path:** `delivery/architecture/ai-native-sequential-pipeline-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/ai-native-sequential-pipeline-architecture/metadata.json b/delivery/architecture/ai-native-sequential-pipeline-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6eccf687794fd249c7e66ecd962c8989d0e7ccb4 --- /dev/null +++ b/delivery/architecture/ai-native-sequential-pipeline-architecture/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "ai-native-sequential-pipeline-architecture", + "workflow_id": "ai-native-sequential-pipeline-architecture", + "title": "AI-Native Sequential Pipeline Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [ + "agentic", + "ai-orchestration" + ], + "use_cases": [ + "delivery", + "agentic", + "ai-orchestration" + ], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "ai-native", + "sequential-pipeline", + "agentic-ai", + "llm-microservices", + "architecture-diagram" + ], + "description": "A sequential pipeline architecture chaining multiple agents in a fixed order (parse → enrich → analyze → format), which is a common 'LLM microservices' setup when each step can be isolated. This structure is often used in document processing and ETL-like workflows because each step is testable and predictable.", + "source_path": "", + "repo_path": "delivery/architecture/ai-native-sequential-pipeline-architecture" +} diff --git a/delivery/architecture/ai-native-sequential-pipeline-architecture/workflow.fz b/delivery/architecture/ai-native-sequential-pipeline-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..1366040981dc0453068e1f692dfe412b1d338ad1 --- /dev/null +++ b/delivery/architecture/ai-native-sequential-pipeline-architecture/workflow.fz @@ -0,0 +1,18 @@ +Trigger { # Trigger +n1: circle label:"Start" +n2: rectangle label:"Incoming request" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Pipeline.n3.handle(top) [label="Input"] +} +Pipeline { # Sequential Pipeline +n3: rectangle label:"Agent A: Parse input" +n4: rectangle label:"Agent B: Enrich data" +n5: rectangle label:"Agent C: Analyze" +n6: rectangle label:"Agent D: Format output" +n7: circle label:"Done" +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n6.handle(top) -> Trigger.n2.handle(bottom) [label="Final output"] +} diff --git a/delivery/architecture/ai-orchestration-sequential-pipeline/README.md b/delivery/architecture/ai-orchestration-sequential-pipeline/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3a6e6e936eac8d87ca51d758aa9dee6e76559680 --- /dev/null +++ b/delivery/architecture/ai-orchestration-sequential-pipeline/README.md @@ -0,0 +1,19 @@ +# AI Orchestration - Sequential Pipeline + +An assembly-line architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. Best for tasks with clear sequential dependencies — document processing, content production pipelines, compliance workflows. + +**Template ID:** `ai-orchestration-sequential-pipeline` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** ai-orchestration +**Complexity:** 2/5 +**Nodes:** 5 +**Lanes:** 2 +**Tags:** [ai-native, sequential-pipeline, assembly-line, architecture-diagram, orchestration] +**Source path:** `` +**Repo path:** `delivery/architecture/ai-orchestration-sequential-pipeline` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/ai-orchestration-sequential-pipeline/metadata.json b/delivery/architecture/ai-orchestration-sequential-pipeline/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3ed3aba7042a5e090e558b991a8520dc663ad48d --- /dev/null +++ b/delivery/architecture/ai-orchestration-sequential-pipeline/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "ai-orchestration-sequential-pipeline", + "workflow_id": "ai-orchestration-sequential-pipeline", + "title": "AI Orchestration - Sequential Pipeline", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "delivery", + "ai-orchestration" + ], + "complexity": 2, + "num_nodes": 5, + "num_lanes": 2, + "tags": [ + "ai-native", + "sequential-pipeline", + "assembly-line", + "architecture-diagram", + "orchestration" + ], + "description": "An assembly-line architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. Best for tasks with clear sequential dependencies — document processing, content production pipelines, compliance workflows.", + "source_path": "", + "repo_path": "delivery/architecture/ai-orchestration-sequential-pipeline" +} diff --git a/delivery/architecture/ai-orchestration-sequential-pipeline/workflow.fz b/delivery/architecture/ai-orchestration-sequential-pipeline/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..1d7076493007afa29860550bb1a067c5f4a06e70 --- /dev/null +++ b/delivery/architecture/ai-orchestration-sequential-pipeline/workflow.fz @@ -0,0 +1,19 @@ +Trigger { # User + n1: circle label="Start" + n2: rectangle label="Submit complex task" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Pipeline.n3.handle(top) [label="Task"] +} + +Pipeline { # Sequential Pipeline + n3: rectangle label="Agent A: Parse input" + n4: rectangle label="Agent B: Enrich data" + n5: rectangle label="Agent C: Analyze" + n6: rectangle label="Agent D: Format output" + n7: circle label="Done" + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> n5.handle(left) + n5.handle(right) -> n6.handle(left) + n6.handle(right) -> n7.handle(left) + n6.handle(top) -> Trigger.n2.handle(bottom) [label="Final output"] +} diff --git a/delivery/architecture/event-driven-event-streaming-pipeline-architecture/README.md b/delivery/architecture/event-driven-event-streaming-pipeline-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1a84593ae2657a888e493bf87679f739e3c6fbee --- /dev/null +++ b/delivery/architecture/event-driven-event-streaming-pipeline-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven Streaming Pipeline Architecture + +A real-time event streaming pipeline architecture diagram with IoT sensors, application logs, and clickstream data flowing through Kafka into Apache Flink for window aggregation, anomaly detection, and multi-sink output to data lakes and dashboards. This template visualizes end-to-end stream processing from ingestion through transformation to storage and alerting. Essential for data engineers building real-time analytics and monitoring platforms. + +**Template ID:** `event-driven-event-streaming-pipeline-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [event-streaming, kafka, apache-flink, stream-processing, real-time-analytics, iot, data-pipeline, architecture-diagram] +**Source path:** `` +**Repo path:** `delivery/architecture/event-driven-event-streaming-pipeline-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/event-driven-event-streaming-pipeline-architecture/metadata.json b/delivery/architecture/event-driven-event-streaming-pipeline-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..63f04ae9910a49bb9e5666c83f7124918ff91dd3 --- /dev/null +++ b/delivery/architecture/event-driven-event-streaming-pipeline-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "event-driven-event-streaming-pipeline-architecture", + "workflow_id": "event-driven-event-streaming-pipeline-architecture", + "title": "Event-Driven Streaming Pipeline Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "event-streaming", + "kafka", + "apache-flink", + "stream-processing", + "real-time-analytics", + "iot", + "data-pipeline", + "architecture-diagram" + ], + "description": "A real-time event streaming pipeline architecture diagram with IoT sensors, application logs, and clickstream data flowing through Kafka into Apache Flink for window aggregation, anomaly detection, and multi-sink output to data lakes and dashboards. This template visualizes end-to-end stream processing from ingestion through transformation to storage and alerting. Essential for data engineers building real-time analytics and monitoring platforms.", + "source_path": "", + "repo_path": "delivery/architecture/event-driven-event-streaming-pipeline-architecture" +} diff --git a/delivery/architecture/event-driven-event-streaming-pipeline-architecture/workflow.fz b/delivery/architecture/event-driven-event-streaming-pipeline-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ed1e035e964acd8cdf389dba5ec6f44be4baebe1 --- /dev/null +++ b/delivery/architecture/event-driven-event-streaming-pipeline-architecture/workflow.fz @@ -0,0 +1,44 @@ +Sources { # Data Sources +n1: rectangle label:"IoT Sensor Stream" +n2: rectangle label:"Application Logs" +n3: rectangle label:"User Clickstream" +n4: rectangle label:"Transaction Events" +n1.handle(bottom) -> Ingestion.n5.handle(top) [label="MQTT"] +n2.handle(bottom) -> Ingestion.n5.handle(top) [label="Fluentd"] +n3.handle(bottom) -> Ingestion.n6.handle(top) [label="Kafka Connect"] +n4.handle(bottom) -> Ingestion.n6.handle(top) [label="CDC"] +} +Ingestion { # Stream Ingestion (Kafka) +n5: rectangle label:"Kafka Topic: Raw Events" +n6: rectangle label:"Kafka Topic: Enriched Events" +n7: rectangle label:"Schema Registry Validate" +n8: rectangle label:"Partition by Key" +n5.handle(right) -> n7.handle(left) [label="Validate"] +n7.handle(right) -> n8.handle(left) [label="Schema OK"] +n8.handle(bottom) -> Processing.n9.handle(top) [label="Partitioned"] +n6.handle(bottom) -> Processing.n9.handle(top) [label="Stream"] +} +Processing { # Stream Processing (Flink/Spark) +n9: rectangle label:"Window Aggregation" +n10: rectangle label:"Filter and Transform" +n11: rectangle label:"Join Streams" +n12: diamond label:"Anomaly Detected?" +n13: rectangle label:"Emit Alert Event" +n14: rectangle label:"Write to Sink" +n9.handle(right) -> n10.handle(left) [label="5-min Window"] +n10.handle(right) -> n11.handle(left) [label="Cleaned"] +n11.handle(right) -> n12.handle(left) [label="Enriched"] +n12.handle(right) -> n14.handle(left) [label="Normal"] +n12.handle(bottom) -> n13.handle(top) [label="Anomaly"] +n13.handle(right) -> n14.handle(left) [label="Alert + Data"] +n14.handle(bottom) -> Sinks.n15.handle(top) [label="Output"] +} +Sinks { # Data Sinks +n15: rectangle label:"Data Lake (S3/HDFS)" +n16: rectangle label:"Real-Time Dashboard" +n17: rectangle label:"Alert Notification" +n18: rectangle label:"Search Index (Elasticsearch)" +n15.handle(right) -> n16.handle(left) [label="Batch Analytics"] +n16.handle(right) -> n17.handle(left) [label="Alerts"] +n17.handle(right) -> n18.handle(left) [label="Index"] +} diff --git a/delivery/architecture/gitops-deployment-architecture/README.md b/delivery/architecture/gitops-deployment-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1fcb36b75d4a4ab196300bdc40cd77c885a47c27 --- /dev/null +++ b/delivery/architecture/gitops-deployment-architecture/README.md @@ -0,0 +1,19 @@ +# GitOps Deployment Architecture + +A GitOps deployment architecture diagram with developer Git workflow, CI/CD pipeline building and pushing container images, ArgoCD or Flux detecting Git manifest changes, drift detection, automatic cluster synchronization, and rolling update deployment to Kubernetes. This template models the GitOps paradigm where Git is the single source of truth for both application code and infrastructure state, enabling declarative, auditable, and reproducible deployments. Critical for teams adopting GitOps practices for Kubernetes deployments. + +**Template ID:** `gitops-deployment-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 4 +**Tags:** [gitops, argocd, flux, kubernetes-deployment, declarative-infrastructure, drift-detection, rolling-update, architecture-diagram] +**Source path:** `` +**Repo path:** `delivery/architecture/gitops-deployment-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/gitops-deployment-architecture/metadata.json b/delivery/architecture/gitops-deployment-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..59e88b5bb5b4b30a1d3218bd31f3e6e50d109f4d --- /dev/null +++ b/delivery/architecture/gitops-deployment-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "gitops-deployment-architecture", + "workflow_id": "gitops-deployment-architecture", + "title": "GitOps Deployment Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 4, + "tags": [ + "gitops", + "argocd", + "flux", + "kubernetes-deployment", + "declarative-infrastructure", + "drift-detection", + "rolling-update", + "architecture-diagram" + ], + "description": "A GitOps deployment architecture diagram with developer Git workflow, CI/CD pipeline building and pushing container images, ArgoCD or Flux detecting Git manifest changes, drift detection, automatic cluster synchronization, and rolling update deployment to Kubernetes. This template models the GitOps paradigm where Git is the single source of truth for both application code and infrastructure state, enabling declarative, auditable, and reproducible deployments. Critical for teams adopting GitOps practices for Kubernetes deployments.", + "source_path": "", + "repo_path": "delivery/architecture/gitops-deployment-architecture" +} diff --git a/delivery/architecture/gitops-deployment-architecture/workflow.fz b/delivery/architecture/gitops-deployment-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d5913888d67b467882ec1aa5fc67acaddfa8e58a --- /dev/null +++ b/delivery/architecture/gitops-deployment-architecture/workflow.fz @@ -0,0 +1,45 @@ +Developer { # Developer +n1: circle label:"Code Change" +n2: rectangle label:"Git Push to Main" +n3: rectangle label:"Open Pull Request" +n4: rectangle label:"Merge After Review" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Feature Branch"] +n3.handle(right) -> n4.handle(left) [label="Approved"] +n4.handle(bottom) -> CICD.n5.handle(top) [label="Trigger"] +} +CICD { # CI/CD Pipeline +n5: rectangle label:"Run Tests and Lint" +n6: rectangle label:"Build Container Image" +n7: rectangle label:"Push to Registry" +n8: rectangle label:"Update Manifest in Git" +n5.handle(right) -> n6.handle(left) [label="Tests Pass"] +n6.handle(right) -> n7.handle(left) [label="Tag: sha-abc123"] +n7.handle(right) -> n8.handle(left) [label="Update Image Tag"] +n8.handle(bottom) -> GitOps.n9.handle(top) [label="Commit Manifest"] +} +GitOps { # GitOps Controller (ArgoCD/Flux) +n9: rectangle label:"Detect Git Diff" +n10: rectangle label:"Compare Desired vs Live" +n11: diamond label:"Drift Detected?" +n12: rectangle label:"Sync to Cluster" +n13: rectangle label:"State Already Synced" +n14: rectangle label:"Health Check" +n9.handle(right) -> n10.handle(left) [label="Poll/Webhook"] +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(right) -> n14.handle(left) [label="Apply"] +n14.handle(bottom) -> Cluster.n15.handle(top) [label="Deploy"] +} +Cluster { # Kubernetes Cluster +n15: rectangle label:"Rolling Update Deployment" +n16: rectangle label:"New Pods Created" +n17: rectangle label:"Old Pods Terminated" +n18: rectangle label:"Service Routes Traffic" +n19: circle label:"Deployment Complete" +n15.handle(right) -> n16.handle(left) [label="Scale Up"] +n16.handle(right) -> n17.handle(left) [label="Healthy"] +n17.handle(right) -> n18.handle(left) [label="Cutover"] +n18.handle(right) -> n19.handle(left) +} diff --git a/delivery/architecture/microservices-strangler-fig-migration/README.md b/delivery/architecture/microservices-strangler-fig-migration/README.md new file mode 100644 index 0000000000000000000000000000000000000000..055909dca249b7758f584e469d076e243da92173 --- /dev/null +++ b/delivery/architecture/microservices-strangler-fig-migration/README.md @@ -0,0 +1,19 @@ +# Microservices Strangler Fig Migration Architecture + +A strangler fig migration architecture diagram showing the incremental replacement of a legacy monolith with new microservices, using a routing layer to split traffic between old and new systems. This template models the proven migration strategy where new features are built as microservices while legacy endpoints are gradually retired. Essential for teams modernizing legacy systems without risky big-bang rewrites. + +**Template ID:** `microservices-strangler-fig-migration` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 16 +**Lanes:** 4 +**Tags:** [strangler-fig, legacy-migration, monolith-decomposition, anti-corruption-layer, incremental-migration, modernization, architecture-diagram] +**Source path:** `` +**Repo path:** `delivery/architecture/microservices-strangler-fig-migration` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/microservices-strangler-fig-migration/metadata.json b/delivery/architecture/microservices-strangler-fig-migration/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..84880981a7141394dd669077ccd70b92c57d7514 --- /dev/null +++ b/delivery/architecture/microservices-strangler-fig-migration/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "microservices-strangler-fig-migration", + "workflow_id": "microservices-strangler-fig-migration", + "title": "Microservices Strangler Fig Migration Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 4, + "num_nodes": 16, + "num_lanes": 4, + "tags": [ + "strangler-fig", + "legacy-migration", + "monolith-decomposition", + "anti-corruption-layer", + "incremental-migration", + "modernization", + "architecture-diagram" + ], + "description": "A strangler fig migration architecture diagram showing the incremental replacement of a legacy monolith with new microservices, using a routing layer to split traffic between old and new systems. This template models the proven migration strategy where new features are built as microservices while legacy endpoints are gradually retired. Essential for teams modernizing legacy systems without risky big-bang rewrites.", + "source_path": "", + "repo_path": "delivery/architecture/microservices-strangler-fig-migration" +} diff --git a/delivery/architecture/microservices-strangler-fig-migration/workflow.fz b/delivery/architecture/microservices-strangler-fig-migration/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..995fa13ad8695e812aa8da916b1951774cf01708 --- /dev/null +++ b/delivery/architecture/microservices-strangler-fig-migration/workflow.fz @@ -0,0 +1,41 @@ +Client { # Client +n1: circle label:"User Request" +n2: rectangle label:"Anti-Corruption Layer" +n3: rectangle label:"Receive Response" +n4: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Router.n5.handle(top) [label="Translate"] +n3.handle(right) -> n4.handle(left) +} +Router { # Strangler Fig Router +n5: rectangle label:"Inspect Request Path" +n6: diamond label:"Migrated Endpoint?" +n7: rectangle label:"Route to New Service" +n8: rectangle label:"Route to Legacy Monolith" +n9: rectangle label:"Log Migration Metrics" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) [label="Yes"] +n6.handle(bottom) -> n8.handle(top) [label="No"] +n7.handle(bottom) -> NewServices.n10.handle(top) [label="Forward"] +n8.handle(bottom) -> Legacy.n14.handle(top) [label="Forward"] +n7.handle(right) -> n9.handle(left) [label="Track"] +n8.handle(right) -> n9.handle(left) [label="Track"] +} +NewServices { # New Microservices +n10: rectangle label:"Process in New Service" +n11: rectangle label:"New Service Database" +n12: rectangle label:"Publish Domain Event" +n13: rectangle label:"Return Response" +n10.handle(right) -> n11.handle(left) [label="Query"] +n11.handle(right) -> n12.handle(left) [label="Write"] +n12.handle(right) -> n13.handle(left) +n13.handle(top) -> Client.n3.handle(bottom) [label="New Response"] +} +Legacy { # Legacy Monolith +n14: rectangle label:"Process in Monolith" +n15: rectangle label:"Legacy Database" +n16: rectangle label:"Return Legacy Response" +n14.handle(right) -> n15.handle(left) [label="SQL"] +n15.handle(right) -> n16.handle(left) [label="Result"] +n16.handle(top) -> Client.n3.handle(bottom) [label="Legacy Response"] +} diff --git a/delivery/architecture/saga-orchestration-pattern-architecture/README.md b/delivery/architecture/saga-orchestration-pattern-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..909705cc351311dd4a9deaec2e3e039be0359e0c --- /dev/null +++ b/delivery/architecture/saga-orchestration-pattern-architecture/README.md @@ -0,0 +1,19 @@ +# Saga Orchestration Pattern Architecture + +A saga orchestration architecture diagram with a central orchestrator coordinating multi-step distributed transactions across Order, Inventory, and Payment services, with a dedicated compensation chain for rollback on failure. This template models the orchestration-based saga pattern where a single coordinator manages the transaction lifecycle and triggers compensating actions when any step fails. Essential for architects implementing reliable distributed transactions without two-phase commit. + +**Template ID:** `saga-orchestration-pattern-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** ai-orchestration +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 5 +**Tags:** [saga-pattern, orchestration, distributed-transaction, compensation, microservices, rollback, consistency, architecture-diagram] +**Source path:** `` +**Repo path:** `delivery/architecture/saga-orchestration-pattern-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/saga-orchestration-pattern-architecture/metadata.json b/delivery/architecture/saga-orchestration-pattern-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7f2c04b1777b81b717b6d2b97d27bfa8ecd0b927 --- /dev/null +++ b/delivery/architecture/saga-orchestration-pattern-architecture/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "saga-orchestration-pattern-architecture", + "workflow_id": "saga-orchestration-pattern-architecture", + "title": "Saga Orchestration Pattern Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "delivery", + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 5, + "tags": [ + "saga-pattern", + "orchestration", + "distributed-transaction", + "compensation", + "microservices", + "rollback", + "consistency", + "architecture-diagram" + ], + "description": "A saga orchestration architecture diagram with a central orchestrator coordinating multi-step distributed transactions across Order, Inventory, and Payment services, with a dedicated compensation chain for rollback on failure. This template models the orchestration-based saga pattern where a single coordinator manages the transaction lifecycle and triggers compensating actions when any step fails. Essential for architects implementing reliable distributed transactions without two-phase commit.", + "source_path": "", + "repo_path": "delivery/architecture/saga-orchestration-pattern-architecture" +} diff --git a/delivery/architecture/saga-orchestration-pattern-architecture/workflow.fz b/delivery/architecture/saga-orchestration-pattern-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..cb2b5938d154d35994a494180e517a4b14a71ad5 --- /dev/null +++ b/delivery/architecture/saga-orchestration-pattern-architecture/workflow.fz @@ -0,0 +1,60 @@ +Orchestrator { # Saga Orchestrator +n1: circle label:"Start Saga" +n2: rectangle label:"Create Saga Instance" +n3: rectangle label:"Execute Step 1: Create Order" +n8: rectangle label:"Execute Step 2: Reserve Inventory" +n12: rectangle label:"Execute Step 3: Process Payment" +n16: diamond label:"All Steps Succeeded?" +n17: rectangle label:"Mark Saga Complete" +n18: rectangle label:"Begin Compensation" +n19: circle label:"Saga Finished" +n25: rectangle label:"Rollback Confirmed" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Initialize"] +n3.handle(bottom) -> OrderService.n4.handle(top) [label="Command"] +n8.handle(bottom) -> InventoryService.n9.handle(top) [label="Command"] +n12.handle(bottom) -> PaymentService.n13.handle(top) [label="Command"] +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> n18.handle(top) [label="No"] +n17.handle(right) -> n19.handle(left) +n18.handle(bottom) -> Compensation.n20.handle(top) [label="Rollback"] +n25.handle(right) -> n19.handle(left) +} +OrderService { # Order Service +n4: rectangle label:"Create Order Record" +n5: rectangle label:"Return Order ID" +n6: rectangle label:"Send Order Result" +n7: rectangle label:"Forward to Orchestrator" +n4.handle(right) -> n5.handle(left) [label="Persisted"] +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(top) -> Orchestrator.n8.handle(bottom) [label="Step 1 OK"] +} +InventoryService { # Inventory Service +n9: rectangle label:"Reserve Stock Items" +n10: rectangle label:"Return Reservation ID" +n11: rectangle label:"Forward to Orchestrator" +n9.handle(right) -> n10.handle(left) [label="Reserved"] +n10.handle(right) -> n11.handle(left) +n11.handle(top) -> Orchestrator.n12.handle(bottom) [label="Step 2 OK"] +} +PaymentService { # Payment Service +n13: rectangle label:"Charge Payment Method" +n14: rectangle label:"Return Transaction ID" +n15: rectangle label:"Forward to Orchestrator" +n13.handle(right) -> n14.handle(left) [label="Charged"] +n14.handle(right) -> n15.handle(left) +n15.handle(top) -> Orchestrator.n16.handle(bottom) [label="Result"] +} +Compensation { # Compensation Steps +n20: rectangle label:"Reverse Payment" +n21: rectangle label:"Release Inventory" +n22: rectangle label:"Cancel Order" +n23: rectangle label:"Notify Orchestrator" +n24: rectangle label:"Send Rollback Status" +n20.handle(right) -> n21.handle(left) [label="Refund"] +n21.handle(right) -> n22.handle(left) [label="Unreserve"] +n22.handle(right) -> n23.handle(left) [label="Cancelled"] +n23.handle(right) -> n24.handle(left) +n24.handle(top) -> Orchestrator.n25.handle(bottom) [label="Rollback Complete"] +} diff --git a/delivery/architecture/serverless-data-pipeline-architecture/README.md b/delivery/architecture/serverless-data-pipeline-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..06a91c33323d8e5e7bd7ae05ae1684f9793a5f1a --- /dev/null +++ b/delivery/architecture/serverless-data-pipeline-architecture/README.md @@ -0,0 +1,19 @@ +# Serverless Data Pipeline Architecture + +A serverless data pipeline architecture diagram with Kinesis ingestion, Lambda transformation functions, S3 data lake storage zones (raw and curated), Glue catalog registration, and Athena query engine feeding QuickSight dashboards and SageMaker ML models. This template models a complete serverless ETL pipeline from data ingestion through transformation, cataloging, and analytics without managing any infrastructure. Ideal for data teams building cost-effective analytics platforms. + +**Template ID:** `serverless-data-pipeline-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [serverless-data-pipeline, kinesis, glue, athena, s3-data-lake, etl, sagemaker, architecture-diagram] +**Source path:** `` +**Repo path:** `delivery/architecture/serverless-data-pipeline-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/architecture/serverless-data-pipeline-architecture/metadata.json b/delivery/architecture/serverless-data-pipeline-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..0b5bf812b4c418392b2882498fbc73d4657d544b --- /dev/null +++ b/delivery/architecture/serverless-data-pipeline-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "serverless-data-pipeline-architecture", + "workflow_id": "serverless-data-pipeline-architecture", + "title": "Serverless Data Pipeline Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "serverless-data-pipeline", + "kinesis", + "glue", + "athena", + "s3-data-lake", + "etl", + "sagemaker", + "architecture-diagram" + ], + "description": "A serverless data pipeline architecture diagram with Kinesis ingestion, Lambda transformation functions, S3 data lake storage zones (raw and curated), Glue catalog registration, and Athena query engine feeding QuickSight dashboards and SageMaker ML models. This template models a complete serverless ETL pipeline from data ingestion through transformation, cataloging, and analytics without managing any infrastructure. Ideal for data teams building cost-effective analytics platforms.", + "source_path": "", + "repo_path": "delivery/architecture/serverless-data-pipeline-architecture" +} diff --git a/delivery/architecture/serverless-data-pipeline-architecture/workflow.fz b/delivery/architecture/serverless-data-pipeline-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ecdbf690462768badbb59c0d910cac623ef213ed --- /dev/null +++ b/delivery/architecture/serverless-data-pipeline-architecture/workflow.fz @@ -0,0 +1,41 @@ +Ingestion { # Data Ingestion +n1: rectangle label:"Kinesis Data Stream" +n2: rectangle label:"API Gateway Endpoint" +n3: rectangle label:"IoT Core MQTT" +n4: rectangle label:"Kinesis Firehose" +n1.handle(right) -> n4.handle(left) [label="Stream"] +n2.handle(right) -> n4.handle(left) [label="Batch"] +n3.handle(right) -> n4.handle(left) [label="Device Data"] +n4.handle(bottom) -> Transform.n5.handle(top) [label="Buffer + Deliver"] +} +Transform { # Serverless Transform +n5: rectangle label:"Lambda Transform Function" +n6: rectangle label:"Validate Schema" +n7: diamond label:"Valid Record?" +n8: rectangle label:"Enrich with Reference Data" +n9: rectangle label:"Route to Error Bucket" +n10: rectangle label:"Partition by Date" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Valid"] +n7.handle(bottom) -> n9.handle(top) [label="Invalid"] +n8.handle(right) -> n10.handle(left) [label="Enriched"] +n10.handle(bottom) -> Storage.n11.handle(top) [label="Partitioned"] +} +Storage { # Data Lake Storage +n11: rectangle label:"S3 Raw Zone" +n12: rectangle label:"S3 Curated Zone" +n13: rectangle label:"Glue Catalog" +n14: rectangle label:"Athena Query Engine" +n11.handle(right) -> n12.handle(left) [label="Glue ETL Job"] +n12.handle(right) -> n13.handle(left) [label="Register Schema"] +n13.handle(right) -> n14.handle(left) [label="Queryable"] +} +Analytics { # Analytics Layer +n15: rectangle label:"QuickSight Dashboard" +n16: rectangle label:"SageMaker ML Model" +n17: rectangle label:"Redshift Data Warehouse" +n14.handle(bottom) -> Analytics.n15.handle(top) [label="Visualize"] +n14.handle(bottom) -> Analytics.n16.handle(top) [label="Train Model"] +n14.handle(bottom) -> Analytics.n17.handle(top) [label="COPY INTO"] +} diff --git a/delivery/devops/backup-restore-workflow/README.md b/delivery/devops/backup-restore-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f5208ee0521f7e74a9a2394f66541467eeb30aa8 --- /dev/null +++ b/delivery/devops/backup-restore-workflow/README.md @@ -0,0 +1,19 @@ +# Backup Restore Workflow + +Backup and restore workflow with scheduled backups, offsite replication, retention policy enforcement, restore testing, and RTO/RPO validation. + +**Template ID:** `backup-restore-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [backup-restore, disaster-recovery, rpo-rto, snapshot, data-protection, recovery-testing] +**Source path:** `devops/backup-restore` +**Repo path:** `delivery/devops/backup-restore-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/devops/backup-restore-workflow/metadata.json b/delivery/devops/backup-restore-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b2e1a417c266e132233c2332bf62fcd36dec10f3 --- /dev/null +++ b/delivery/devops/backup-restore-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "backup-restore-workflow", + "workflow_id": "backup-restore", + "title": "Backup Restore Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "backup-restore", + "disaster-recovery", + "rpo-rto", + "snapshot", + "data-protection", + "recovery-testing" + ], + "description": "Backup and restore workflow with scheduled backups, offsite replication, retention policy enforcement, restore testing, and RTO/RPO validation.", + "source_path": "devops/backup-restore", + "repo_path": "delivery/devops/backup-restore-workflow" +} diff --git a/delivery/devops/backup-restore-workflow/workflow.fz b/delivery/devops/backup-restore-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e9b334ee987ffdbc0716b220493fc7e609f8a500 --- /dev/null +++ b/delivery/devops/backup-restore-workflow/workflow.fz @@ -0,0 +1,47 @@ +BackupScheduler { # Backup Scheduler +n1: circle label:"Start" +n2: rectangle label:"Trigger scheduled backup" +n3: rectangle label:"Select backup targets" +n4: rectangle label:"Verify backup completion" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> BackupAgent.n6.handle(top) [label="Execute"] +n4.handle(right) -> n5.handle(left) +} +BackupAgent { # Backup Agent +n6: rectangle label:"Create database snapshot" +n7: rectangle label:"Compress backup files" +n8: rectangle label:"Encrypt with AES-256" +n9: rectangle label:"Upload to S3 bucket" +n10: diamond label:"Upload successful?" +n11: rectangle label:"Update backup catalog" +n12: rectangle label:"Retry upload" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n12.handle(top) [label="No"] +n11.handle(top) -> BackupScheduler.n4.handle(bottom) [label="Complete"] +n12.handle(top) -> n9.handle(bottom) [label="Retry"] +} +RestoreProcess { # Restore Process +n13: rectangle label:"Select restore point" +n14: rectangle label:"Download from S3" +n15: rectangle label:"Decrypt backup" +n16: rectangle label:"Decompress files" +n17: diamond label:"Restore type?" +n18: rectangle label:"Full database restore" +n19: rectangle label:"Point-in-time recovery" +n20: rectangle label:"Verify data integrity" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Full"] +n17.handle(bottom) -> n19.handle(top) [label="PITR"] +n18.handle(right) -> n20.handle(left) +n19.handle(right) -> n20.handle(top) +n20.handle(top) -> BackupScheduler.n4.handle(bottom) [label="Restored"] +} \ No newline at end of file diff --git a/delivery/devops/ci-cd-pipeline-workflow/README.md b/delivery/devops/ci-cd-pipeline-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..89917c81f9d84dc732b02026a7d8b699b933ae47 --- /dev/null +++ b/delivery/devops/ci-cd-pipeline-workflow/README.md @@ -0,0 +1,19 @@ +# Ci Cd Pipeline Workflow + +Full CI/CD pipeline with code checkout, linting, unit tests, artifact building, staging deployment, smoke tests, production deployment, and automatic rollback on failure. + +**Template ID:** `ci-cd-pipeline-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 22 +**Lanes:** 3 +**Tags:** [ci-cd, continuous-integration, continuous-deployment, github-actions, artifact-registry, staging, production, rollback] +**Source path:** `devops/ci-cd-pipeline` +**Repo path:** `delivery/devops/ci-cd-pipeline-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/devops/ci-cd-pipeline-workflow/metadata.json b/delivery/devops/ci-cd-pipeline-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3edef4ce4c581a597b1212d86306ddc5064c9026 --- /dev/null +++ b/delivery/devops/ci-cd-pipeline-workflow/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "ci-cd-pipeline-workflow", + "workflow_id": "ci-cd-pipeline", + "title": "Ci Cd Pipeline Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 4, + "num_nodes": 22, + "num_lanes": 3, + "tags": [ + "ci-cd", + "continuous-integration", + "continuous-deployment", + "github-actions", + "artifact-registry", + "staging", + "production", + "rollback" + ], + "description": "Full CI/CD pipeline with code checkout, linting, unit tests, artifact building, staging deployment, smoke tests, production deployment, and automatic rollback on failure.", + "source_path": "devops/ci-cd-pipeline", + "repo_path": "delivery/devops/ci-cd-pipeline-workflow" +} diff --git a/delivery/devops/ci-cd-pipeline-workflow/workflow.fz b/delivery/devops/ci-cd-pipeline-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..5eb02e6ffdfc7a1e9b834395a0970895777497e8 --- /dev/null +++ b/delivery/devops/ci-cd-pipeline-workflow/workflow.fz @@ -0,0 +1,53 @@ +Developer { # Developer +n1: circle label:"Start" +n2: rectangle label:"Push code to repository" +n3: rectangle label:"Review pipeline status" +n4: rectangle label:"Merge to main branch" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> CI.n6.handle(top) [label="Trigger build"] +n3.handle(right) -> n4.handle(left) +n4.handle(bottom) -> CD.n18.handle(top) [label="Deploy"] +} +CI { # Continuous Integration +n6: rectangle label:"Checkout source code" +n7: rectangle label:"Install dependencies" +n8: rectangle label:"Run linting checks" +n9: diamond label:"Lint passed?" +n10: rectangle label:"Run unit tests" +n11: diamond label:"Tests passed?" +n12: rectangle label:"Build artifacts" +n13: rectangle label:"Push to artifact registry" +n14: rectangle label:"Notify build failure" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n14.handle(top) [label="No"] +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n14.handle(top) [label="No"] +n12.handle(right) -> n13.handle(left) +n13.handle(top) -> Developer.n3.handle(bottom) [label="Build ready"] +n14.handle(top) -> Developer.n3.handle(bottom) [label="Failed"] +} +CD { # Continuous Deployment +n15: rectangle label:"Pull latest artifacts" +n16: rectangle label:"Deploy to staging" +n17: diamond label:"Staging tests pass?" +n18: rectangle label:"Deploy to production" +n19: rectangle label:"Run smoke tests" +n20: diamond label:"Health check OK?" +n21: rectangle label:"Update load balancer" +n22: rectangle label:"Rollback deployment" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n22.handle(top) [label="No"] +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) [label="Yes"] +n20.handle(bottom) -> n22.handle(top) [label="No"] +n21.handle(top) -> Developer.n5.handle(bottom) [label="Live"] +n22.handle(top) -> Developer.n3.handle(bottom) [label="Rolled back"] +} \ No newline at end of file diff --git a/delivery/devops/infrastructure-provisioning-workflow/README.md b/delivery/devops/infrastructure-provisioning-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a391b60b0b76ab5d9e425b978b1ca4005e37b112 --- /dev/null +++ b/delivery/devops/infrastructure-provisioning-workflow/README.md @@ -0,0 +1,19 @@ +# Infrastructure Provisioning Workflow + +Infrastructure as Code provisioning workflow with Terraform plan, approval gates, state management, resource creation, and drift detection. + +**Template ID:** `infrastructure-provisioning-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [infrastructure-provisioning, terraform, iac, cloud-resources, gitops, state-management] +**Source path:** `devops/infrastructure-provisioning` +**Repo path:** `delivery/devops/infrastructure-provisioning-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/devops/infrastructure-provisioning-workflow/metadata.json b/delivery/devops/infrastructure-provisioning-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b4dd3cb141371e931a57749a5f344844f90c4198 --- /dev/null +++ b/delivery/devops/infrastructure-provisioning-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "infrastructure-provisioning-workflow", + "workflow_id": "infrastructure-provisioning", + "title": "Infrastructure Provisioning Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "infrastructure-provisioning", + "terraform", + "iac", + "cloud-resources", + "gitops", + "state-management" + ], + "description": "Infrastructure as Code provisioning workflow with Terraform plan, approval gates, state management, resource creation, and drift detection.", + "source_path": "devops/infrastructure-provisioning", + "repo_path": "delivery/devops/infrastructure-provisioning-workflow" +} diff --git a/delivery/devops/infrastructure-provisioning-workflow/workflow.fz b/delivery/devops/infrastructure-provisioning-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..8ba71b252176c0efc7bb742f189833fda3213bc0 --- /dev/null +++ b/delivery/devops/infrastructure-provisioning-workflow/workflow.fz @@ -0,0 +1,46 @@ +DevOps { # DevOps Engineer +n1: circle label:"Start" +n2: rectangle label:"Define infrastructure requirements" +n3: rectangle label:"Write Terraform configuration" +n4: rectangle label:"Review provisioned resources" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Terraform.n6.handle(top) [label="Plan"] +n4.handle(right) -> n5.handle(left) +} +Terraform { # Terraform +n6: rectangle label:"Initialize providers" +n7: rectangle label:"Generate execution plan" +n8: diamond label:"Plan valid?" +n9: rectangle label:"Display planned changes" +n10: rectangle label:"Show validation errors" +n11: diamond label:"Approve changes?" +n12: rectangle label:"Apply configuration" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(top) -> DevOps.n3.handle(bottom) [label="Fix config"] +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> DevOps.n3.handle(bottom) [label="No"] +n12.handle(bottom) -> CloudProvider.n13.handle(top) [label="Provision"] +} +CloudProvider { # Cloud Provider +n13: rectangle label:"Create VPC and subnets" +n14: rectangle label:"Provision compute instances" +n15: rectangle label:"Configure load balancers" +n16: rectangle label:"Set up security groups" +n17: diamond label:"All resources healthy?" +n18: rectangle label:"Output resource IDs" +n19: rectangle label:"Rollback failed resources" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(top) -> DevOps.n4.handle(bottom) [label="Complete"] +n19.handle(top) -> Terraform.n12.handle(bottom) [label="Retry"] +} diff --git a/delivery/devops/load-testing-workflow/README.md b/delivery/devops/load-testing-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d3fb0b2730c81b381d7fb18870bdf968266a355d --- /dev/null +++ b/delivery/devops/load-testing-workflow/README.md @@ -0,0 +1,19 @@ +# Load Testing Workflow + +Load testing workflow with test scenario design, gradual ramp-up, performance metrics collection, bottleneck identification, and capacity recommendations. + +**Template ID:** `load-testing-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [load-testing, performance-testing, stress-testing, k6, jmeter, capacity-planning] +**Source path:** `devops/load-testing` +**Repo path:** `delivery/devops/load-testing-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/devops/load-testing-workflow/metadata.json b/delivery/devops/load-testing-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..89625912aed7c289f845533a7f416632616604bb --- /dev/null +++ b/delivery/devops/load-testing-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "load-testing-workflow", + "workflow_id": "load-testing", + "title": "Load Testing Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "load-testing", + "performance-testing", + "stress-testing", + "k6", + "jmeter", + "capacity-planning" + ], + "description": "Load testing workflow with test scenario design, gradual ramp-up, performance metrics collection, bottleneck identification, and capacity recommendations.", + "source_path": "devops/load-testing", + "repo_path": "delivery/devops/load-testing-workflow" +} diff --git a/delivery/devops/load-testing-workflow/workflow.fz b/delivery/devops/load-testing-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..f2ce9c1dbd91866d933f49037ceb4f205d99ee0c --- /dev/null +++ b/delivery/devops/load-testing-workflow/workflow.fz @@ -0,0 +1,45 @@ +QAEngineer { # QA Engineer +n1: circle label:"Start" +n2: rectangle label:"Define load test scenarios" +n3: rectangle label:"Configure virtual users" +n4: rectangle label:"Review test results" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> LoadGenerator.n6.handle(top) [label="Execute"] +n4.handle(right) -> n5.handle(left) +} +LoadGenerator { # Load Generator +n6: rectangle label:"Spin up worker nodes" +n7: rectangle label:"Ramp up virtual users" +n8: rectangle label:"Execute test scripts" +n9: diamond label:"Target load reached?" +n10: rectangle label:"Maintain steady state" +n11: rectangle label:"Increase load gradually" +n12: rectangle label:"Ramp down users" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n11.handle(top) [label="No"] +n10.handle(right) -> n12.handle(left) +n11.handle(top) -> n8.handle(bottom) [label="Continue"] +n12.handle(bottom) -> Metrics.n13.handle(top) [label="Collect metrics"] +} +Metrics { # Metrics Collection +n13: rectangle label:"Aggregate response times" +n14: rectangle label:"Calculate percentiles" +n15: rectangle label:"Measure throughput" +n16: diamond label:"SLA met?" +n17: rectangle label:"Generate pass report" +n18: rectangle label:"Flag performance issues" +n19: rectangle label:"Create detailed report" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> n18.handle(top) [label="No"] +n17.handle(right) -> n19.handle(left) +n18.handle(right) -> n19.handle(top) +n19.handle(top) -> QAEngineer.n4.handle(bottom) [label="Results ready"] +} diff --git a/delivery/patterns/blue-green-deploy-workflow/README.md b/delivery/patterns/blue-green-deploy-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..77c0f245b04000c9db4ecf08e430fff257e2f805 --- /dev/null +++ b/delivery/patterns/blue-green-deploy-workflow/README.md @@ -0,0 +1,19 @@ +# Blue Green Deploy Workflow + +Blue-green deployment pattern with parallel environment setup, smoke testing, load balancer traffic switch, and instant rollback capability. + +**Template ID:** `blue-green-deploy-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** delivery +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [blue-green-deployment, zero-downtime, traffic-switching, rollback, load-balancer, release-management] +**Source path:** `patterns/blue-green-deploy` +**Repo path:** `delivery/patterns/blue-green-deploy-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/patterns/blue-green-deploy-workflow/metadata.json b/delivery/patterns/blue-green-deploy-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..787d2bb87f5d7caecc083ed043d987e69f65f726 --- /dev/null +++ b/delivery/patterns/blue-green-deploy-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "blue-green-deploy-workflow", + "workflow_id": "blue-green-deploy", + "title": "Blue Green Deploy Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "delivery", + "secondary_use_cases": [], + "use_cases": [ + "delivery" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "blue-green-deployment", + "zero-downtime", + "traffic-switching", + "rollback", + "load-balancer", + "release-management" + ], + "description": "Blue-green deployment pattern with parallel environment setup, smoke testing, load balancer traffic switch, and instant rollback capability.", + "source_path": "patterns/blue-green-deploy", + "repo_path": "delivery/patterns/blue-green-deploy-workflow" +} diff --git a/delivery/patterns/blue-green-deploy-workflow/workflow.fz b/delivery/patterns/blue-green-deploy-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..44c2696442a022bfcf6156380e11c423fc0e1dba --- /dev/null +++ b/delivery/patterns/blue-green-deploy-workflow/workflow.fz @@ -0,0 +1,48 @@ +CI { # CI Pipeline +n1: circle label:"Start" +n2: rectangle label:"Build new version" +n3: rectangle label:"Run automated tests" +n4: rectangle label:"Verify deployment success" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> BlueGreen.n6.handle(top) [label="Deploy"] +n4.handle(right) -> n5.handle(left) +} +BlueGreen { # Blue-Green Controller +n6: rectangle label:"Identify current environment" +n7: diamond label:"Current active?" +n8: rectangle label:"Deploy to Green" +n9: rectangle label:"Deploy to Blue" +n10: rectangle label:"Run smoke tests" +n11: diamond label:"Tests passed?" +n12: rectangle label:"Switch load balancer" +n13: rectangle label:"Rollback deployment" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Blue"] +n7.handle(bottom) -> n9.handle(top) [label="Green"] +n8.handle(right) -> n10.handle(left) +n9.handle(right) -> n10.handle(top) +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(bottom) -> LoadBalancer.n14.handle(top) [label="Switch"] +n13.handle(top) -> CI.n4.handle(bottom) [label="Failed"] +} +LoadBalancer { # Load Balancer +n14: rectangle label:"Update target group" +n15: rectangle label:"Drain old connections" +n16: rectangle label:"Route traffic to new env" +n17: rectangle label:"Monitor error rates" +n18: diamond label:"Stable?" +n19: rectangle label:"Mark deployment complete" +n20: rectangle label:"Revert to old environment" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Yes"] +n18.handle(bottom) -> n20.handle(top) [label="No"] +n19.handle(top) -> CI.n4.handle(bottom) [label="Success"] +n20.handle(top) -> CI.n4.handle(bottom) [label="Rolled back"] +} diff --git a/delivery/patterns/saga-pattern-workflow/README.md b/delivery/patterns/saga-pattern-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7b063524ed831abf7acc510ebb4d9f6129cd5927 --- /dev/null +++ b/delivery/patterns/saga-pattern-workflow/README.md @@ -0,0 +1,19 @@ +# Saga Pattern Workflow + +Saga orchestration pattern for distributed transactions across Order, Payment, and Shipping services with automatic compensation rollback on failures. + +**Template ID:** `saga-pattern-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** delivery +**Secondary use cases:** ai-orchestration +**Complexity:** 5/5 +**Nodes:** 20 +**Lanes:** 4 +**Tags:** [saga-pattern, distributed-transactions, microservices, compensation, orchestration, eventual-consistency, rollback] +**Source path:** `patterns/saga-pattern` +**Repo path:** `delivery/patterns/saga-pattern-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/delivery/patterns/saga-pattern-workflow/metadata.json b/delivery/patterns/saga-pattern-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..1c954d1a24bf6a4b21396b17f00dbd2ddba1189c --- /dev/null +++ b/delivery/patterns/saga-pattern-workflow/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "saga-pattern-workflow", + "workflow_id": "saga-pattern", + "title": "Saga Pattern Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "delivery", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "delivery", + "ai-orchestration" + ], + "complexity": 5, + "num_nodes": 20, + "num_lanes": 4, + "tags": [ + "saga-pattern", + "distributed-transactions", + "microservices", + "compensation", + "orchestration", + "eventual-consistency", + "rollback" + ], + "description": "Saga orchestration pattern for distributed transactions across Order, Payment, and Shipping services with automatic compensation rollback on failures.", + "source_path": "patterns/saga-pattern", + "repo_path": "delivery/patterns/saga-pattern-workflow" +} diff --git a/delivery/patterns/saga-pattern-workflow/workflow.fz b/delivery/patterns/saga-pattern-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..4db2e0e6fe35c611786d5a04aa526f23a773f9d9 --- /dev/null +++ b/delivery/patterns/saga-pattern-workflow/workflow.fz @@ -0,0 +1,50 @@ +Orchestrator { # Saga Orchestrator +n1: circle label:"Start" +n2: rectangle label:"Begin distributed transaction" +n3: rectangle label:"Coordinate saga steps" +n4: rectangle label:"Commit saga" +n5: rectangle label:"Trigger compensations" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> OrderService.n7.handle(top) [label="Step 1"] +n3.handle(bottom) -> PaymentService.n11.handle(top) [label="Step 2"] +n4.handle(right) -> n6.handle(left) +n5.handle(bottom) -> PaymentService.n15.handle(top) [label="Rollback"] +} +OrderService { # Order Service +n7: rectangle label:"Create order record" +n8: diamond label:"Order created?" +n9: rectangle label:"Reserve inventory" +n10: rectangle label:"Cancel order" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(top) -> Orchestrator.n3.handle(bottom) [label="Success"] +n10.handle(top) -> Orchestrator.n5.handle(bottom) [label="Failed"] +} +PaymentService { # Payment Service +n11: rectangle label:"Process payment" +n12: diamond label:"Payment successful?" +n13: rectangle label:"Confirm transaction" +n14: rectangle label:"Report payment failure" +n15: rectangle label:"Refund payment" +n16: rectangle label:"Release inventory" +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) [label="Yes"] +n12.handle(bottom) -> n14.handle(top) [label="No"] +n13.handle(bottom) -> ShippingService.n17.handle(top) [label="Step 3"] +n14.handle(top) -> Orchestrator.n5.handle(bottom) [label="Compensate"] +n15.handle(right) -> n16.handle(left) +n16.handle(top) -> OrderService.n10.handle(bottom) [label="Undo order"] +} +ShippingService { # Shipping Service +n17: rectangle label:"Schedule shipment" +n18: diamond label:"Shipment scheduled?" +n19: rectangle label:"Generate tracking number" +n20: rectangle label:"Report shipping failure" +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Yes"] +n18.handle(bottom) -> n20.handle(top) [label="No"] +n19.handle(top) -> Orchestrator.n4.handle(bottom) [label="Complete"] +n20.handle(top) -> Orchestrator.n5.handle(bottom) [label="Compensate"] +} diff --git a/handoff/architecture/bulkhead-isolation-architecture/README.md b/handoff/architecture/bulkhead-isolation-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e45011924ce64aff5e4caf5f6d3d293b6920beac --- /dev/null +++ b/handoff/architecture/bulkhead-isolation-architecture/README.md @@ -0,0 +1,19 @@ +# Bulkhead Isolation Architecture + +A bulkhead isolation architecture diagram with separate thread pools for critical, standard, and batch workloads, each with independent connection pools, exhaustion detection, and backpressure strategies to prevent one workload from starving others. This template models the bulkhead pattern inspired by ship hull compartments, where resource isolation ensures that a failure or overload in one component cannot cascade to others. Critical for systems requiring guaranteed availability for high-priority operations. + +**Template ID:** `bulkhead-isolation-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [bulkhead-pattern, resource-isolation, thread-pool, backpressure, fault-isolation, resilience, priority-routing, architecture-diagram] +**Source path:** `` +**Repo path:** `handoff/architecture/bulkhead-isolation-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/architecture/bulkhead-isolation-architecture/metadata.json b/handoff/architecture/bulkhead-isolation-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ec76a7ba7dfac52fae2857ad47ec7ce1f415bf07 --- /dev/null +++ b/handoff/architecture/bulkhead-isolation-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "bulkhead-isolation-architecture", + "workflow_id": "bulkhead-isolation-architecture", + "title": "Bulkhead Isolation Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "bulkhead-pattern", + "resource-isolation", + "thread-pool", + "backpressure", + "fault-isolation", + "resilience", + "priority-routing", + "architecture-diagram" + ], + "description": "A bulkhead isolation architecture diagram with separate thread pools for critical, standard, and batch workloads, each with independent connection pools, exhaustion detection, and backpressure strategies to prevent one workload from starving others. This template models the bulkhead pattern inspired by ship hull compartments, where resource isolation ensures that a failure or overload in one component cannot cascade to others. Critical for systems requiring guaranteed availability for high-priority operations.", + "source_path": "", + "repo_path": "handoff/architecture/bulkhead-isolation-architecture" +} diff --git a/handoff/architecture/bulkhead-isolation-architecture/workflow.fz b/handoff/architecture/bulkhead-isolation-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..4a2d49cbf615f0fe7b2e7b4a1c6af39df417d433 --- /dev/null +++ b/handoff/architecture/bulkhead-isolation-architecture/workflow.fz @@ -0,0 +1,43 @@ +Gateway { # API Gateway +n1: circle label:"Incoming Request" +n2: rectangle label:"Classify Request Type" +n3: diamond label:"Request Category?" +n4: rectangle label:"Route to Critical Pool" +n5: rectangle label:"Route to Standard Pool" +n6: rectangle label:"Route to Batch Pool" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) [label="Critical"] +n3.handle(bottom) -> n5.handle(top) [label="Standard"] +n3.handle(left) -> n6.handle(right) [label="Batch"] +n4.handle(bottom) -> CriticalPool.n7.handle(top) [label="Priority"] +n5.handle(bottom) -> StandardPool.n11.handle(top) [label="Normal"] +n6.handle(bottom) -> BatchPool.n15.handle(top) [label="Low Priority"] +} +CriticalPool { # Critical Thread Pool (10 threads) +n7: rectangle label:"Dedicated Connection Pool" +n8: diamond label:"Pool Exhausted?" +n9: rectangle label:"Process Payment Request" +n10: rectangle label:"Queue with Timeout" +n7.handle(right) -> n8.handle(left) [label="Check"] +n8.handle(right) -> n9.handle(left) [label="Available"] +n8.handle(bottom) -> n10.handle(top) [label="Exhausted"] +} +StandardPool { # Standard Thread Pool (20 threads) +n11: rectangle label:"Shared Connection Pool" +n12: diamond label:"Pool Exhausted?" +n13: rectangle label:"Process API Request" +n14: rectangle label:"Return 503 Service Unavailable" +n11.handle(right) -> n12.handle(left) [label="Check"] +n12.handle(right) -> n13.handle(left) [label="Available"] +n12.handle(bottom) -> n14.handle(top) [label="Exhausted"] +} +BatchPool { # Batch Thread Pool (5 threads) +n15: rectangle label:"Rate-Limited Pool" +n16: diamond label:"Pool Exhausted?" +n17: rectangle label:"Process Batch Job" +n18: rectangle label:"Backpressure: Delay Retry" +n15.handle(right) -> n16.handle(left) [label="Check"] +n16.handle(right) -> n17.handle(left) [label="Available"] +n16.handle(bottom) -> n18.handle(top) [label="Exhausted"] +} diff --git a/handoff/architecture/cell-based-architecture/README.md b/handoff/architecture/cell-based-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a88634279e0e645a7199354e52a823bd42bcf16e --- /dev/null +++ b/handoff/architecture/cell-based-architecture/README.md @@ -0,0 +1,19 @@ +# Cell-Based Architecture + +A cell-based architecture diagram with geographic routing to independent, self-contained cells (US-East, EU-West), each with its own gateway, compute, database, cache, and message queue, plus shared services for cross-cell replication and global configuration. This template models the cell architecture pattern used by hyperscale systems to achieve blast radius isolation, where failures in one cell cannot affect users in another. Key for architects designing systems that require extreme availability and fault isolation. + +**Template ID:** `cell-based-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 20 +**Lanes:** 4 +**Tags:** [cell-based-architecture, blast-radius, geographic-routing, fault-isolation, independent-cells, cross-cell-replication, hyperscale, architecture-diagram] +**Source path:** `` +**Repo path:** `handoff/architecture/cell-based-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/architecture/cell-based-architecture/metadata.json b/handoff/architecture/cell-based-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..99bedc4dd6447e9fb68a201a7fbebfc7a41bb471 --- /dev/null +++ b/handoff/architecture/cell-based-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "cell-based-architecture", + "workflow_id": "cell-based-architecture", + "title": "Cell-Based Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 4, + "num_nodes": 20, + "num_lanes": 4, + "tags": [ + "cell-based-architecture", + "blast-radius", + "geographic-routing", + "fault-isolation", + "independent-cells", + "cross-cell-replication", + "hyperscale", + "architecture-diagram" + ], + "description": "A cell-based architecture diagram with geographic routing to independent, self-contained cells (US-East, EU-West), each with its own gateway, compute, database, cache, and message queue, plus shared services for cross-cell replication and global configuration. This template models the cell architecture pattern used by hyperscale systems to achieve blast radius isolation, where failures in one cell cannot affect users in another. Key for architects designing systems that require extreme availability and fault isolation.", + "source_path": "", + "repo_path": "handoff/architecture/cell-based-architecture" +} diff --git a/handoff/architecture/cell-based-architecture/workflow.fz b/handoff/architecture/cell-based-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..491599d74608f8cb0dd1942e1a65a42336197db4 --- /dev/null +++ b/handoff/architecture/cell-based-architecture/workflow.fz @@ -0,0 +1,48 @@ +GlobalRouter { # Global Router +n1: circle label:"User Request" +n2: rectangle label:"Geographic Routing" +n3: diamond label:"User Cell Assignment?" +n4: rectangle label:"Route to Cell A" +n5: rectangle label:"Route to Cell B" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) [label="US-East"] +n3.handle(bottom) -> n5.handle(top) [label="EU-West"] +n4.handle(bottom) -> CellA.n6.handle(top) [label="Forward"] +n5.handle(bottom) -> CellB.n12.handle(top) [label="Forward"] +} +CellA { # Cell A (US-East) +n6: rectangle label:"Cell Gateway" +n7: rectangle label:"Compute Layer" +n8: rectangle label:"Cell Database" +n9: rectangle label:"Cell Cache" +n10: rectangle label:"Cell Message Queue" +n11: circle label:"Cell Response" +n6.handle(right) -> n7.handle(left) [label="Process"] +n7.handle(right) -> n8.handle(left) [label="Read/Write"] +n7.handle(bottom) -> n9.handle(top) [label="Cache"] +n7.handle(bottom) -> n10.handle(top) [label="Async"] +n8.handle(right) -> n11.handle(left) +n8.handle(bottom) -> SharedServices.n18.handle(top) [label="Replicate"] +} +CellB { # Cell B (EU-West) +n12: rectangle label:"Cell Gateway" +n13: rectangle label:"Compute Layer" +n14: rectangle label:"Cell Database" +n15: rectangle label:"Cell Cache" +n16: rectangle label:"Cell Message Queue" +n17: circle label:"Cell Response" +n12.handle(right) -> n13.handle(left) [label="Process"] +n13.handle(right) -> n14.handle(left) [label="Read/Write"] +n13.handle(bottom) -> n15.handle(top) [label="Cache"] +n13.handle(bottom) -> n16.handle(top) [label="Async"] +n14.handle(right) -> n17.handle(left) +n14.handle(bottom) -> SharedServices.n18.handle(top) [label="Replicate"] +} +SharedServices { # Shared Services (Cross-Cell) +n18: rectangle label:"Cross-Cell Replication" +n19: rectangle label:"Global Config Service" +n20: rectangle label:"Monitoring and Alerting" +n18.handle(right) -> n19.handle(left) [label="Sync Config"] +n19.handle(right) -> n20.handle(left) [label="Health"] +} diff --git a/handoff/architecture/microservices-service-discovery-architecture/README.md b/handoff/architecture/microservices-service-discovery-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e4530e366e1f280e84714f9694f1d2df775c50e3 --- /dev/null +++ b/handoff/architecture/microservices-service-discovery-architecture/README.md @@ -0,0 +1,19 @@ +# Microservices Service Discovery Architecture + +A service discovery architecture diagram with Consul or Eureka registry, client-side load balancing, health check heartbeats, and automatic instance registration and deregistration. This template visualizes how microservices dynamically locate each other without hardcoded endpoints, enabling elastic scaling and self-healing infrastructure. Key for platform teams building resilient service-to-service communication. + +**Template ID:** `microservices-service-discovery-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 16 +**Lanes:** 3 +**Tags:** [service-discovery, consul, eureka, health-check, client-side-load-balancing, service-registry, dynamic-routing, architecture-diagram] +**Source path:** `` +**Repo path:** `handoff/architecture/microservices-service-discovery-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/architecture/microservices-service-discovery-architecture/metadata.json b/handoff/architecture/microservices-service-discovery-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f923ff79c2de92757511485798b467ce9aeabe95 --- /dev/null +++ b/handoff/architecture/microservices-service-discovery-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "microservices-service-discovery-architecture", + "workflow_id": "microservices-service-discovery-architecture", + "title": "Microservices Service Discovery Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 3, + "num_nodes": 16, + "num_lanes": 3, + "tags": [ + "service-discovery", + "consul", + "eureka", + "health-check", + "client-side-load-balancing", + "service-registry", + "dynamic-routing", + "architecture-diagram" + ], + "description": "A service discovery architecture diagram with Consul or Eureka registry, client-side load balancing, health check heartbeats, and automatic instance registration and deregistration. This template visualizes how microservices dynamically locate each other without hardcoded endpoints, enabling elastic scaling and self-healing infrastructure. Key for platform teams building resilient service-to-service communication.", + "source_path": "", + "repo_path": "handoff/architecture/microservices-service-discovery-architecture" +} diff --git a/handoff/architecture/microservices-service-discovery-architecture/workflow.fz b/handoff/architecture/microservices-service-discovery-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c3cbaf4d7dac8ecfe54afa571f6850f69fc1cf7c --- /dev/null +++ b/handoff/architecture/microservices-service-discovery-architecture/workflow.fz @@ -0,0 +1,59 @@ +Client { # Client Service +n1: circle label:"Service Call Needed" +n2: rectangle label:"Query Service Registry" +n8: rectangle label:"Client-Side Load Balance" +n9: rectangle label:"Send Request to Instance" +n14: rectangle label:"Receive Response" +n15: rectangle label:"Process Result" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Registry.n3.handle(top) [label="Lookup"] +n8.handle(right) -> n9.handle(left) +n9.handle(bottom) -> Target.n10.handle(top) [label="HTTP/gRPC"] +n14.handle(right) -> n15.handle(left) +} +Registry { # Service Registry (Consul/Eureka) +n3: rectangle label:"Receive Lookup Request" +n4: rectangle label:"Check Health Status" +n5: diamond label:"Healthy Instances?" +n6: rectangle label:"Return Instance List" +n7: rectangle label:"Return Service Unavailable" +n18: rectangle label:"Receive Heartbeat" +n19: rectangle label:"Send Registration Ack" +n21: rectangle label:"Receive Ready Signal" +n22: rectangle label:"Send Health Ping" +n24: rectangle label:"Update Health Status" +n27: rectangle label:"Process Removal" +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) [label="Yes"] +n5.handle(bottom) -> n7.handle(top) [label="No"] +n6.handle(top) -> Client.n8.handle(bottom) [label="Endpoints"] +n7.handle(top) -> Client.n14.handle(bottom) [label="503"] +n18.handle(right) -> n19.handle(left) +n19.handle(bottom) -> Target.n20.handle(top) [label="Registered OK"] +n21.handle(right) -> n22.handle(left) +n22.handle(bottom) -> Target.n23.handle(top) [label="Ping"] +} +Target { # Target Service +n10: rectangle label:"Instance A (Primary)" +n11: rectangle label:"Instance B (Replica)" +n12: rectangle label:"Instance C (Replica)" +n13: rectangle label:"Send Response" +n16: rectangle label:"Register on Startup" +n17: rectangle label:"Send Heartbeat" +n20: rectangle label:"Receive Registration Ack" +n23: rectangle label:"Respond to Ping" +n25: rectangle label:"Service Running" +n26: rectangle label:"Deregister on Shutdown" +n10.handle(right) -> n11.handle(left) [label="Replicate"] +n11.handle(right) -> n12.handle(left) [label="Replicate"] +n12.handle(right) -> n13.handle(left) +n13.handle(top) -> Client.n14.handle(bottom) [label="Response"] +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> Registry.n18.handle(bottom) [label="Heartbeat"] +n20.handle(top) -> Registry.n21.handle(bottom) [label="Ready for Ping"] +n23.handle(top) -> Registry.n24.handle(bottom) [label="Healthy"] +n23.handle(right) -> n25.handle(left) +n25.handle(right) -> n26.handle(left) [label="Shutdown"] +n26.handle(top) -> Registry.n27.handle(bottom) [label="Remove"] +} diff --git a/handoff/architecture/serverless-edge-computing-architecture/README.md b/handoff/architecture/serverless-edge-computing-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..51bd694c69433223c7c2dab3a5db2a1e0570e306 --- /dev/null +++ b/handoff/architecture/serverless-edge-computing-architecture/README.md @@ -0,0 +1,19 @@ +# Serverless Edge Computing Architecture + +A serverless edge computing architecture diagram with CloudFront or Cloudflare edge locations, Lambda@Edge functions for A/B testing and geo-personalization, origin shield request collapsing, and cache-first response strategies. This template visualizes how computation moves to the network edge for ultra-low latency responses, with edge functions modifying requests and responses before they reach the origin. Essential for performance-critical applications serving global audiences. + +**Template ID:** `serverless-edge-computing-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 15 +**Lanes:** 3 +**Tags:** [edge-computing, lambda-at-edge, cloudfront, cloudflare, cdn, geo-routing, cache-strategy, architecture-diagram] +**Source path:** `` +**Repo path:** `handoff/architecture/serverless-edge-computing-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/architecture/serverless-edge-computing-architecture/metadata.json b/handoff/architecture/serverless-edge-computing-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d2e45d79019aea2e1082e815747715c6fb8b8676 --- /dev/null +++ b/handoff/architecture/serverless-edge-computing-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "serverless-edge-computing-architecture", + "workflow_id": "serverless-edge-computing-architecture", + "title": "Serverless Edge Computing Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 3, + "num_nodes": 15, + "num_lanes": 3, + "tags": [ + "edge-computing", + "lambda-at-edge", + "cloudfront", + "cloudflare", + "cdn", + "geo-routing", + "cache-strategy", + "architecture-diagram" + ], + "description": "A serverless edge computing architecture diagram with CloudFront or Cloudflare edge locations, Lambda@Edge functions for A/B testing and geo-personalization, origin shield request collapsing, and cache-first response strategies. This template visualizes how computation moves to the network edge for ultra-low latency responses, with edge functions modifying requests and responses before they reach the origin. Essential for performance-critical applications serving global audiences.", + "source_path": "", + "repo_path": "handoff/architecture/serverless-edge-computing-architecture" +} diff --git a/handoff/architecture/serverless-edge-computing-architecture/workflow.fz b/handoff/architecture/serverless-edge-computing-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..13ef0ce9de4267862fab32b6c9b2f09fdb17f32d --- /dev/null +++ b/handoff/architecture/serverless-edge-computing-architecture/workflow.fz @@ -0,0 +1,51 @@ +User { # End User +n1: circle label:"Browser Request" +n2: rectangle label:"DNS Resolution (Route 53)" +n21: rectangle label:"Receive Optimized Response" +n22: circle label:"Page Rendered" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Edge.n3.handle(top) [label="Nearest PoP"] +n21.handle(right) -> n22.handle(left) +} +Edge { # Edge Network (CloudFront/Cloudflare) +n3: rectangle label:"Edge Location PoP" +n4: diamond label:"Cache Hit?" +n5: rectangle label:"Return Cached Response" +n6: rectangle label:"Edge Function (Lambda@Edge)" +n7: rectangle label:"A/B Test Routing" +n8: rectangle label:"Geo-Based Personalization" +n19: rectangle label:"Cache and Forward Response" +n20: rectangle label:"Send to User" +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="HIT"] +n4.handle(bottom) -> n6.handle(top) [label="MISS"] +n5.handle(top) -> User.n21.handle(bottom) [label="Fast Response"] +n6.handle(right) -> n7.handle(left) [label="Modify Request"] +n7.handle(right) -> n8.handle(left) [label="Personalize"] +n8.handle(bottom) -> Origin.n9.handle(top) [label="Forward"] +n19.handle(right) -> n20.handle(left) +n20.handle(top) -> User.n21.handle(bottom) [label="Response"] +} +Origin { # Origin Services +n9: rectangle label:"Origin Shield" +n10: rectangle label:"Application Load Balancer" +n11: rectangle label:"Serverless API" +n12: rectangle label:"Static Asset Store (S3)" +n13: rectangle label:"Generate Response" +n14: rectangle label:"Prepare Origin Response" +n15: rectangle label:"Package Response" +n16: rectangle label:"Forward Origin Response" +n17: rectangle label:"Send Cached Response" +n18: rectangle label:"Deliver to Edge" +n9.handle(right) -> n10.handle(left) [label="Collapse Requests"] +n10.handle(right) -> n11.handle(left) [label="Dynamic"] +n10.handle(bottom) -> n12.handle(top) [label="Static"] +n11.handle(right) -> n13.handle(left) [label="Compute"] +n12.handle(right) -> n13.handle(left) [label="Assets"] +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(top) -> Edge.n19.handle(bottom) [label="Cache + Return"] +} diff --git a/handoff/architecture/serverless-multi-cloud-architecture/README.md b/handoff/architecture/serverless-multi-cloud-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..54d8ca5b6b9a9d41420d843e7c9fb059586d25fa --- /dev/null +++ b/handoff/architecture/serverless-multi-cloud-architecture/README.md @@ -0,0 +1,19 @@ +# Serverless Multi-Cloud Architecture + +A multi-cloud serverless architecture diagram with DNS-based traffic routing between AWS and Azure regions, automatic failover on health check failures, and bi-directional data replication with conflict resolution across cloud providers. This template models the multi-cloud strategy for maximum availability and vendor independence, using serverless services from both AWS (Lambda, DynamoDB) and Azure (Functions, Cosmos DB). Critical for enterprises requiring cloud provider redundancy. + +**Template ID:** `serverless-multi-cloud-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [multi-cloud, aws, azure, cloud-failover, dns-routing, data-replication, vendor-independence, architecture-diagram] +**Source path:** `` +**Repo path:** `handoff/architecture/serverless-multi-cloud-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/architecture/serverless-multi-cloud-architecture/metadata.json b/handoff/architecture/serverless-multi-cloud-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..946892481eca55bcfb425f7b7ac1e6c873e8ce28 --- /dev/null +++ b/handoff/architecture/serverless-multi-cloud-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "serverless-multi-cloud-architecture", + "workflow_id": "serverless-multi-cloud-architecture", + "title": "Serverless Multi-Cloud Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "multi-cloud", + "aws", + "azure", + "cloud-failover", + "dns-routing", + "data-replication", + "vendor-independence", + "architecture-diagram" + ], + "description": "A multi-cloud serverless architecture diagram with DNS-based traffic routing between AWS and Azure regions, automatic failover on health check failures, and bi-directional data replication with conflict resolution across cloud providers. This template models the multi-cloud strategy for maximum availability and vendor independence, using serverless services from both AWS (Lambda, DynamoDB) and Azure (Functions, Cosmos DB). Critical for enterprises requiring cloud provider redundancy.", + "source_path": "", + "repo_path": "handoff/architecture/serverless-multi-cloud-architecture" +} diff --git a/handoff/architecture/serverless-multi-cloud-architecture/workflow.fz b/handoff/architecture/serverless-multi-cloud-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ee4287d2b1cc8b73932742ed82928a4c43b99393 --- /dev/null +++ b/handoff/architecture/serverless-multi-cloud-architecture/workflow.fz @@ -0,0 +1,55 @@ +TrafficManager { # Global Traffic Manager +n1: circle label:"User Request" +n2: rectangle label:"DNS-Based Routing" +n3: diamond label:"Primary Cloud Healthy?" +n4: rectangle label:"Route to Primary (AWS)" +n5: rectangle label:"Failover to Secondary (Azure)" +n20: rectangle label:"Receive Cloud Response" +n21: circle label:"Return to User" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) [label="Healthy"] +n3.handle(bottom) -> n5.handle(top) [label="Unhealthy"] +n4.handle(bottom) -> AWS.n6.handle(top) [label="Forward"] +n5.handle(bottom) -> Azure.n13.handle(top) [label="Forward"] +n20.handle(right) -> n21.handle(left) +} +AWS { # AWS Region +n6: rectangle label:"API Gateway" +n7: rectangle label:"Lambda Functions" +n8: rectangle label:"DynamoDB" +n9: rectangle label:"S3 Storage" +n10: rectangle label:"CloudWatch Monitoring" +n11: rectangle label:"Prepare Response" +n12: rectangle label:"Return to TrafficManager" +n6.handle(right) -> n7.handle(left) [label="Invoke"] +n7.handle(right) -> n8.handle(left) [label="Read/Write"] +n7.handle(bottom) -> n9.handle(top) [label="Store"] +n8.handle(right) -> n10.handle(left) [label="Monitor"] +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> TrafficManager.n20.handle(bottom) [label="AWS Response"] +} +Azure { # Azure Region +n13: rectangle label:"Azure API Management" +n14: rectangle label:"Azure Functions" +n15: rectangle label:"Cosmos DB" +n16: rectangle label:"Blob Storage" +n17: rectangle label:"Azure Monitor" +n18: rectangle label:"Prepare Response" +n19: rectangle label:"Return to TrafficManager" +n13.handle(right) -> n14.handle(left) [label="Invoke"] +n14.handle(right) -> n15.handle(left) [label="Read/Write"] +n14.handle(bottom) -> n16.handle(top) [label="Store"] +n15.handle(right) -> n17.handle(left) [label="Monitor"] +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> TrafficManager.n20.handle(bottom) [label="Azure Response"] +} +DataSync { # Cross-Cloud Sync +n22: rectangle label:"Event Bridge" +n23: rectangle label:"Bi-Directional Replication" +n24: rectangle label:"Conflict Resolution" +n22.handle(right) -> n23.handle(left) [label="CDC Events"] +n23.handle(right) -> n24.handle(left) [label="Last-Write-Wins"] +} diff --git a/handoff/business-operations/support-ticket-workflow/README.md b/handoff/business-operations/support-ticket-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e0b5bd734af2df63bca464f81452976f95cb2fb1 --- /dev/null +++ b/handoff/business-operations/support-ticket-workflow/README.md @@ -0,0 +1,19 @@ +# Support Ticket Workflow + +Customer support ticket workflow with auto-categorization, SLA tracking, agent assignment, escalation rules, and satisfaction survey. + +**Template ID:** `support-ticket-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** handoff +**Secondary use cases:** support +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [support-ticket, helpdesk, zendesk, sla, ticket-routing, customer-service] +**Source path:** `business-operations/support-ticket` +**Repo path:** `handoff/business-operations/support-ticket-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/business-operations/support-ticket-workflow/metadata.json b/handoff/business-operations/support-ticket-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..13387717d9f484bde5aa94ea5a3684158f80f906 --- /dev/null +++ b/handoff/business-operations/support-ticket-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "support-ticket-workflow", + "workflow_id": "support-ticket", + "title": "Support Ticket Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "handoff", + "secondary_use_cases": [ + "support" + ], + "use_cases": [ + "handoff", + "support" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "support-ticket", + "helpdesk", + "zendesk", + "sla", + "ticket-routing", + "customer-service" + ], + "description": "Customer support ticket workflow with auto-categorization, SLA tracking, agent assignment, escalation rules, and satisfaction survey.", + "source_path": "business-operations/support-ticket", + "repo_path": "handoff/business-operations/support-ticket-workflow" +} diff --git a/handoff/business-operations/support-ticket-workflow/workflow.fz b/handoff/business-operations/support-ticket-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..a183a677934c7f561ae2bd4a3e9a02ad3033fdb6 --- /dev/null +++ b/handoff/business-operations/support-ticket-workflow/workflow.fz @@ -0,0 +1,50 @@ +Customer { # Customer +n1: circle label:"Start" +n2: rectangle label:"Submit support request" +n3: rectangle label:"Receive ticket number" +n4: rectangle label:"Provide additional info" +n5: rectangle label:"Rate support experience" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Triage.n7.handle(top) [label="Create ticket"] +n3.handle(bottom) -> Agent.n14.handle(top) [label="Reply"] +n4.handle(bottom) -> Agent.n14.handle(top) [label="Update"] +n5.handle(right) -> n6.handle(left) +} +Triage { # Triage System +n7: rectangle label:"Parse ticket content" +n8: rectangle label:"Classify by category" +n9: diamond label:"Priority level?" +n10: rectangle label:"Route to L1 queue" +n11: rectangle label:"Route to L2 queue" +n12: rectangle label:"Escalate to L3" +n13: rectangle label:"Send confirmation email" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Low/Medium"] +n9.handle(bottom) -> n11.handle(top) [label="High"] +n9.handle(left) -> n12.handle(top) [label="Critical"] +n10.handle(bottom) -> Agent.n14.handle(top) [label="Assign"] +n11.handle(bottom) -> Agent.n14.handle(top) [label="Assign"] +n12.handle(bottom) -> Agent.n14.handle(top) [label="Assign"] +n13.handle(top) -> Customer.n3.handle(bottom) [label="Ticket created"] +} +Agent { # Support Agent +n14: rectangle label:"Review ticket details" +n15: diamond label:"Can resolve?" +n16: rectangle label:"Provide solution" +n17: rectangle label:"Request more info" +n18: rectangle label:"Escalate to specialist" +n19: diamond label:"Customer satisfied?" +n20: rectangle label:"Close ticket" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="Need info"] +n15.handle(left) -> n18.handle(top) [label="No - Complex"] +n16.handle(right) -> n19.handle(left) +n17.handle(top) -> Customer.n4.handle(bottom) [label="Request sent"] +n18.handle(bottom) -> Triage.n12.handle(bottom) [label="Escalate"] +n19.handle(right) -> n20.handle(left) [label="Yes"] +n19.handle(bottom) -> n14.handle(bottom) [label="No - Reopen"] +n20.handle(top) -> Customer.n5.handle(bottom) [label="Survey sent"] +} \ No newline at end of file diff --git a/handoff/devops/mcp-tool-router/README.md b/handoff/devops/mcp-tool-router/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8edbe938d6ccd1a7f88752505530257f12f76da8 --- /dev/null +++ b/handoff/devops/mcp-tool-router/README.md @@ -0,0 +1,19 @@ +# MCP Tool Router Architecture + +A routing pattern that puts a semantic router in front of MCP tools so the LLM only sees the subset it needs. Uses vector embeddings and cosine similarity to match user intent to tools dynamically. Achieves up to 96% reduction in input tokens when dealing with large tool catalogs. + +**Template ID:** `mcp-tool-router` +**Kind:** architecture +**Source domain:** DevOps +**Primary use case:** handoff +**Secondary use cases:** mcp +**Complexity:** 3/5 +**Nodes:** 8 +**Lanes:** 4 +**Tags:** [mcp, tool-router, semantic-routing, embeddings, token-optimization, architecture-diagram, production-grade] +**Source path:** `` +**Repo path:** `handoff/devops/mcp-tool-router` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/devops/mcp-tool-router/metadata.json b/handoff/devops/mcp-tool-router/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..2abae5ec145e8fd31b0dbd39666f93bb994b117d --- /dev/null +++ b/handoff/devops/mcp-tool-router/metadata.json @@ -0,0 +1,30 @@ +{ + "template_id": "mcp-tool-router", + "workflow_id": "mcp-tool-router", + "title": "MCP Tool Router Architecture", + "kind": "architecture", + "source_domain": "DevOps", + "primary_use_case": "handoff", + "secondary_use_cases": [ + "mcp" + ], + "use_cases": [ + "handoff", + "mcp" + ], + "complexity": 3, + "num_nodes": 8, + "num_lanes": 4, + "tags": [ + "mcp", + "tool-router", + "semantic-routing", + "embeddings", + "token-optimization", + "architecture-diagram", + "production-grade" + ], + "description": "A routing pattern that puts a semantic router in front of MCP tools so the LLM only sees the subset it needs. Uses vector embeddings and cosine similarity to match user intent to tools dynamically. Achieves up to 96% reduction in input tokens when dealing with large tool catalogs.", + "source_path": "", + "repo_path": "handoff/devops/mcp-tool-router" +} diff --git a/handoff/devops/mcp-tool-router/workflow.fz b/handoff/devops/mcp-tool-router/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e7128471664f7d1013048d1102741b3e1f51a3b3 --- /dev/null +++ b/handoff/devops/mcp-tool-router/workflow.fz @@ -0,0 +1,41 @@ +Host { + n1: circle label="User sends prompt" + n2: rectangle label="Agent extracts intent" + n3: rectangle label="Send intent to router" + n4: rectangle label="Receive routed result" + n5: rectangle label="Agent responds to user" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> Router.n6.handle(top) [label="Intent + tool request"] + n4.handle(right) -> n5.handle(left) +} + +Router { + n6: rectangle label="Receive intent" + n7: rectangle label="Semantic match via embeddings" + n8: diamond label="Which MCP server?" + n9: rectangle label="Forward to Server A" + n10: rectangle label="Forward to Server B" + n11: rectangle label="Normalize and return result" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n8.handle(bottom) -> n9.handle(top) [label="Route A"] + n8.handle(right) -> n10.handle(left) [label="Route B"] + n9.handle(bottom) -> ServerA.n12.handle(top) [label="Call Server A"] + n10.handle(bottom) -> ServerB.n14.handle(top) [label="Call Server B"] + n11.handle(top) -> Host.n4.handle(bottom) [label="Final result"] +} + +ServerA { + n12: rectangle label="Execute tool A" + n13: rectangle label="Return A result" + n12.handle(right) -> n13.handle(left) + n13.handle(top) -> Router.n11.handle(bottom) [label="Result A"] +} + +ServerB { + n14: rectangle label="Execute tool B" + n15: rectangle label="Return B result" + n14.handle(right) -> n15.handle(left) + n15.handle(top) -> Router.n11.handle(left) [label="Result B"] +} diff --git a/handoff/devops/on-call-rotation-workflow/README.md b/handoff/devops/on-call-rotation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6efc53108ed1a2a22ee49b88e364f9cfaf5c6f7b --- /dev/null +++ b/handoff/devops/on-call-rotation-workflow/README.md @@ -0,0 +1,19 @@ +# On Call Rotation Workflow + +On-call rotation workflow with schedule creation, shift handoffs, override management, escalation policies, and fair rotation distribution. + +**Template ID:** `on-call-rotation-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** handoff +**Secondary use cases:** incident, security +**Complexity:** 3/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [on-call-rotation, incident-management, pagerduty, escalation, schedule-management, handoff] +**Source path:** `devops/on-call-rotation` +**Repo path:** `handoff/devops/on-call-rotation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/devops/on-call-rotation-workflow/metadata.json b/handoff/devops/on-call-rotation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c70266e676683c4b6ad86efee55cf78e35365f85 --- /dev/null +++ b/handoff/devops/on-call-rotation-workflow/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "on-call-rotation-workflow", + "workflow_id": "on-call-rotation", + "title": "On Call Rotation Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "handoff", + "secondary_use_cases": [ + "incident", + "security" + ], + "use_cases": [ + "handoff", + "incident", + "security" + ], + "complexity": 3, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "on-call-rotation", + "incident-management", + "pagerduty", + "escalation", + "schedule-management", + "handoff" + ], + "description": "On-call rotation workflow with schedule creation, shift handoffs, override management, escalation policies, and fair rotation distribution.", + "source_path": "devops/on-call-rotation", + "repo_path": "handoff/devops/on-call-rotation-workflow" +} diff --git a/handoff/devops/on-call-rotation-workflow/workflow.fz b/handoff/devops/on-call-rotation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d5753194616a51d94a96ad4ea87bd32106dbd876 --- /dev/null +++ b/handoff/devops/on-call-rotation-workflow/workflow.fz @@ -0,0 +1,47 @@ +Scheduler { # On-Call Scheduler +n1: circle label:"Start" +n2: rectangle label:"Load rotation schedule" +n3: rectangle label:"Determine current on-call" +n4: rectangle label:"Complete handoff" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Handoff.n6.handle(top) [label="Rotation due"] +n4.handle(right) -> n5.handle(left) +} +Handoff { # Handoff Process +n6: rectangle label:"Notify outgoing engineer" +n7: rectangle label:"Notify incoming engineer" +n8: diamond label:"Handoff acknowledged?" +n9: rectangle label:"Transfer pager access" +n10: rectangle label:"Escalate to manager" +n11: rectangle label:"Update PagerDuty schedule" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(right) -> n9.handle(top) +n11.handle(bottom) -> Alerting.n12.handle(top) [label="Active"] +} +Alerting { # Alert Routing +n12: rectangle label:"Receive incoming alert" +n13: diamond label:"Severity level?" +n14: rectangle label:"Page on-call immediately" +n15: rectangle label:"Send Slack notification" +n16: rectangle label:"Queue for review" +n17: diamond label:"Acknowledged in 5 min?" +n18: rectangle label:"Escalate to backup" +n19: rectangle label:"Log acknowledgment" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Critical"] +n13.handle(bottom) -> n15.handle(top) [label="Warning"] +n13.handle(left) -> n16.handle(top) [label="Info"] +n14.handle(right) -> n17.handle(left) +n15.handle(right) -> n19.handle(left) +n16.handle(right) -> n19.handle(top) +n17.handle(right) -> n19.handle(left) [label="Yes"] +n17.handle(bottom) -> n18.handle(top) [label="No"] +n18.handle(right) -> n17.handle(top) +n19.handle(top) -> Scheduler.n4.handle(bottom) [label="Handled"] +} diff --git a/handoff/finance/payment-run-workflow/README.md b/handoff/finance/payment-run-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ab70fdc0b97ffaa6e91b8dc16b3229c4beacf210 --- /dev/null +++ b/handoff/finance/payment-run-workflow/README.md @@ -0,0 +1,19 @@ +# Payment Run Workflow + +Accounts payable payment run workflow with batch creation, tiered approval (single/dual based on amount), ACH file generation, check printing, and vendor record updates. + +**Template ID:** `payment-run-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** handoff +**Secondary use cases:** approval, billing +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 3 +**Tags:** [payment-run, accounts-payable, ach-payments, check-run, dual-approval, bank-transfer, vendor-payments] +**Source path:** `finance/payment-run` +**Repo path:** `handoff/finance/payment-run-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/finance/payment-run-workflow/metadata.json b/handoff/finance/payment-run-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ed3f8c29c8a8028074c5d26fe22c496d2a6385e1 --- /dev/null +++ b/handoff/finance/payment-run-workflow/metadata.json @@ -0,0 +1,32 @@ +{ + "template_id": "payment-run-workflow", + "workflow_id": "payment-run", + "title": "Payment Run Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "handoff", + "secondary_use_cases": [ + "approval", + "billing" + ], + "use_cases": [ + "handoff", + "approval", + "billing" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 3, + "tags": [ + "payment-run", + "accounts-payable", + "ach-payments", + "check-run", + "dual-approval", + "bank-transfer", + "vendor-payments" + ], + "description": "Accounts payable payment run workflow with batch creation, tiered approval (single/dual based on amount), ACH file generation, check printing, and vendor record updates.", + "source_path": "finance/payment-run", + "repo_path": "handoff/finance/payment-run-workflow" +} diff --git a/handoff/finance/payment-run-workflow/workflow.fz b/handoff/finance/payment-run-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c57f27846ea2976d1006702b9e1573fb8528288b --- /dev/null +++ b/handoff/finance/payment-run-workflow/workflow.fz @@ -0,0 +1,44 @@ +APClerk { # AP Clerk +n1: circle label:"Start" +n2: rectangle label:"Select invoices for payment" +n3: rectangle label:"Create payment batch" +n4: rectangle label:"Confirm payments sent" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Approval.n6.handle(top) [label="Submit"] +n4.handle(right) -> n5.handle(left) +} +Approval { # Payment Approval +n6: rectangle label:"Review payment batch" +n7: diamond label:"Batch amount?" +n8: rectangle label:"Single approver" +n9: rectangle label:"Dual approval required" +n10: diamond label:"Approved?" +n11: rectangle label:"Return for correction" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="< $50K"] +n7.handle(bottom) -> n9.handle(top) [label=">= $50K"] +n8.handle(right) -> n10.handle(left) +n9.handle(right) -> n10.handle(top) +n10.handle(right) -> Banking.n12.handle(left) [label="Yes"] +n10.handle(bottom) -> n11.handle(top) [label="No"] +n11.handle(top) -> APClerk.n2.handle(bottom) [label="Revise"] +} +Banking { # Banking System +n12: rectangle label:"Generate ACH file" +n13: rectangle label:"Generate check run" +n14: diamond label:"Payment method?" +n15: rectangle label:"Submit to bank" +n16: rectangle label:"Print checks" +n17: rectangle label:"Confirm transmission" +n18: rectangle label:"Update vendor records" +n12.handle(right) -> n14.handle(left) +n13.handle(right) -> n14.handle(top) +n14.handle(right) -> n15.handle(left) [label="ACH"] +n14.handle(bottom) -> n16.handle(top) [label="Check"] +n15.handle(right) -> n17.handle(left) +n16.handle(right) -> n17.handle(top) +n17.handle(right) -> n18.handle(left) +n18.handle(top) -> APClerk.n4.handle(bottom) [label="Complete"] +} diff --git a/handoff/hr/offboarding-workflow/README.md b/handoff/hr/offboarding-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1ab49c57bc5f383a26e50edeb4edd75fce654d53 --- /dev/null +++ b/handoff/hr/offboarding-workflow/README.md @@ -0,0 +1,19 @@ +# Offboarding Workflow + +Employee offboarding workflow with exit interview, knowledge transfer, asset collection, access revocation, final pay processing, and benefits continuation. + +**Template ID:** `offboarding-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** handoff +**Secondary use cases:** offboarding +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [employee-offboarding, exit-interview, access-revocation, asset-return, knowledge-transfer, final-paycheck] +**Source path:** `hr/offboarding` +**Repo path:** `handoff/hr/offboarding-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/hr/offboarding-workflow/metadata.json b/handoff/hr/offboarding-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c19e819c9d224e682fadbd81492e3357d2501ec0 --- /dev/null +++ b/handoff/hr/offboarding-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "offboarding-workflow", + "workflow_id": "offboarding", + "title": "Offboarding Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "handoff", + "secondary_use_cases": [ + "offboarding" + ], + "use_cases": [ + "handoff", + "offboarding" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "employee-offboarding", + "exit-interview", + "access-revocation", + "asset-return", + "knowledge-transfer", + "final-paycheck" + ], + "description": "Employee offboarding workflow with exit interview, knowledge transfer, asset collection, access revocation, final pay processing, and benefits continuation.", + "source_path": "hr/offboarding", + "repo_path": "handoff/hr/offboarding-workflow" +} diff --git a/handoff/hr/offboarding-workflow/workflow.fz b/handoff/hr/offboarding-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c227cec825b29cc9d9fcbbbfceefd2c9c780bbe0 --- /dev/null +++ b/handoff/hr/offboarding-workflow/workflow.fz @@ -0,0 +1,55 @@ +DepartingEmployee { # Departing Employee +n1: circle label:"Start" +n2: rectangle label:"Submit resignation" +n3: rectangle label:"Complete exit interview" +n4: rectangle label:"Return company equipment" +n5: rectangle label:"Receive final paycheck" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> HR.n7.handle(top) [label="Resignation"] +n3.handle(bottom) -> HR.n14.handle(top) [label="Feedback"] +n4.handle(bottom) -> IT.n18.handle(top) [label="Equipment"] +n5.handle(right) -> n6.handle(left) +} +HR { # Human Resources +n7: rectangle label:"Process resignation" +n8: rectangle label:"Calculate last working day" +n9: rectangle label:"Notify payroll" +n10: rectangle label:"Schedule exit interview" +n11: diamond label:"Notice period waived?" +n12: rectangle label:"Process immediate departure" +n13: rectangle label:"Standard notice period" +n14: rectangle label:"Conduct exit interview" +n15: rectangle label:"Document feedback" +n16: rectangle label:"Calculate final pay" +n17: rectangle label:"Process severance if applicable" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(top) -> DepartingEmployee.n3.handle(bottom) [label="Exit now"] +n13.handle(top) -> DepartingEmployee.n3.handle(bottom) [label="Work notice"] +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> DepartingEmployee.n5.handle(bottom) [label="Pay ready"] +} +IT { # IT Department +n18: rectangle label:"Revoke system access" +n19: rectangle label:"Disable email account" +n20: rectangle label:"Backup user data" +n21: rectangle label:"Collect laptop and badge" +n22: diamond label:"All equipment returned?" +n23: rectangle label:"Clear security checklist" +n24: rectangle label:"Charge for missing items" +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(right) -> n22.handle(left) +n22.handle(right) -> n23.handle(left) [label="Yes"] +n22.handle(bottom) -> n24.handle(top) [label="No"] +n23.handle(top) -> DepartingEmployee.n4.handle(bottom) [label="Cleared"] +n24.handle(top) -> DepartingEmployee.n4.handle(bottom) [label="Deducted"] +} diff --git a/handoff/logistics/stock-transfer-workflow/README.md b/handoff/logistics/stock-transfer-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b3048b18ca3284cfc4982f0f14956fc51dde5f2c --- /dev/null +++ b/handoff/logistics/stock-transfer-workflow/README.md @@ -0,0 +1,19 @@ +# Stock Transfer Workflow + +Internal stock transfer workflow with transfer request, source location pick, destination put-away, and inventory record updates across locations. + +**Template ID:** `stock-transfer-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [stock-transfer, inventory-movement, location-transfer, bin-to-bin, wms, inventory-rebalancing] +**Source path:** `logistics/stock-transfer` +**Repo path:** `handoff/logistics/stock-transfer-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/logistics/stock-transfer-workflow/metadata.json b/handoff/logistics/stock-transfer-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..5355892c4336a3c59bdcfb2bb47418a2f1116032 --- /dev/null +++ b/handoff/logistics/stock-transfer-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "stock-transfer-workflow", + "workflow_id": "stock-transfer", + "title": "Stock Transfer Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "stock-transfer", + "inventory-movement", + "location-transfer", + "bin-to-bin", + "wms", + "inventory-rebalancing" + ], + "description": "Internal stock transfer workflow with transfer request, source location pick, destination put-away, and inventory record updates across locations.", + "source_path": "logistics/stock-transfer", + "repo_path": "handoff/logistics/stock-transfer-workflow" +} diff --git a/handoff/logistics/stock-transfer-workflow/workflow.fz b/handoff/logistics/stock-transfer-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..668b091248b908bb5ffc3c4ebefb58d23159f3af --- /dev/null +++ b/handoff/logistics/stock-transfer-workflow/workflow.fz @@ -0,0 +1,28 @@ +supplier { # Supplier + n1: circle label:"Start Stock Transfer" + n4: rectangle label:"Make Stock Transfer decision" + n7: rectangle label:"Continue Stock Transfer process" + n10: circle label:"End Stock Transfer" + n1.handle(bottom) -> warehouse.n2.handle(top) + n4.handle(bottom) -> warehouse.n5.handle(top) + n7.handle(bottom) -> warehouse.n8.handle(top) +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Stock Transfer request" + n5: rectangle label:"Update records for Stock Transfer" + n8: rectangle label:"Continue Stock Transfer process" + n2.handle(bottom) -> iot_sensor.n3.handle(top) [label="Next"] + n5.handle(bottom) -> iot_sensor.n6.handle(top) [label="Done"] + n8.handle(bottom) -> iot_sensor.n9.handle(top) [label="Processed"] +} + +iot_sensor { # Iot_Sensor + n3: rectangle label:"Review Stock Transfer details" + n6: rectangle label:"Continue Stock Transfer process" + n9: diamond label:"Continue Stock Transfer process" + n9.handle(right) -> supplier.n10.handle(bottom) + n9.handle(left) -> warehouse.n8.handle(left) [label="Retry/Rejected"] + n3.handle(right) -> supplier.n4.handle(left) + n6.handle(right) -> supplier.n7.handle(left) +} diff --git a/handoff/logistics/warehouse-transfer-workflow/README.md b/handoff/logistics/warehouse-transfer-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2cfa2da09c0667cf500d872cd085ff8979509449 --- /dev/null +++ b/handoff/logistics/warehouse-transfer-workflow/README.md @@ -0,0 +1,19 @@ +# Warehouse Transfer Workflow + +Inter-warehouse transfer workflow with transfer order creation, shipping from source DC, in-transit tracking, and receiving at destination warehouse. + +**Template ID:** `warehouse-transfer-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [warehouse-transfer, inter-facility, transfer-order, in-transit-inventory, network-optimization, distribution] +**Source path:** `logistics/warehouse-transfer` +**Repo path:** `handoff/logistics/warehouse-transfer-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/logistics/warehouse-transfer-workflow/metadata.json b/handoff/logistics/warehouse-transfer-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..986257949ffbe8bb0fe06965b973708ee5ee6c01 --- /dev/null +++ b/handoff/logistics/warehouse-transfer-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "warehouse-transfer-workflow", + "workflow_id": "warehouse-transfer", + "title": "Warehouse Transfer Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "warehouse-transfer", + "inter-facility", + "transfer-order", + "in-transit-inventory", + "network-optimization", + "distribution" + ], + "description": "Inter-warehouse transfer workflow with transfer order creation, shipping from source DC, in-transit tracking, and receiving at destination warehouse.", + "source_path": "logistics/warehouse-transfer", + "repo_path": "handoff/logistics/warehouse-transfer-workflow" +} diff --git a/handoff/logistics/warehouse-transfer-workflow/workflow.fz b/handoff/logistics/warehouse-transfer-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3e04513b6c2224e5dee5de9ecdd8ee65b949e328 --- /dev/null +++ b/handoff/logistics/warehouse-transfer-workflow/workflow.fz @@ -0,0 +1,27 @@ +supplier { # Supplier + n1: circle label:"Start Warehouse Transfer" + n4: rectangle label:"Make Warehouse Transfer decision" + n7: rectangle label:"Continue Warehouse Transfer process" + n10: circle label:"End Warehouse Transfer" + n1.handle(bottom) -> warehouse.n2.handle(top) + n4.handle(bottom) -> warehouse.n5.handle(top) + n7.handle(bottom) -> warehouse.n8.handle(top) +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Warehouse Transfer request" + n5: rectangle label:"Update records for Warehouse Transfer" + n8: rectangle label:"Continue Warehouse Transfer process" + n2.handle(bottom) -> iot_sensor.n3.handle(top) [label="Next"] + n5.handle(bottom) -> iot_sensor.n6.handle(top) [label="Done"] + n8.handle(bottom) -> iot_sensor.n9.handle(top) [label="Processed"] +} + +iot_sensor { # Iot Sensor + n3: rectangle label:"Review Warehouse Transfer details" + n6: rectangle label:"Continue Warehouse Transfer process" + n9: rectangle label:"Continue Warehouse Transfer process" + n9.handle(right) -> supplier.n10.handle(bottom) + n6.handle(right) -> supplier.n7.handle(left) + n3.handle(right) -> supplier.n4.handle(left) +} diff --git a/handoff/patterns/api-gateway-workflow/README.md b/handoff/patterns/api-gateway-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..aade7ccd87519a768f4bc9f0d68b2df59c27124f --- /dev/null +++ b/handoff/patterns/api-gateway-workflow/README.md @@ -0,0 +1,19 @@ +# Api Gateway Workflow + +API Gateway pattern with request authentication, rate limiting, request routing to backend services, response aggregation, and error handling. + +**Template ID:** `api-gateway-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** handoff +**Secondary use cases:** security, mcp +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [api-gateway, microservices, rate-limiting, request-routing, authentication, load-balancing] +**Source path:** `patterns/api-gateway` +**Repo path:** `handoff/patterns/api-gateway-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/patterns/api-gateway-workflow/metadata.json b/handoff/patterns/api-gateway-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4453dbbca1b616740898b6ba3a8d58e98edeebd9 --- /dev/null +++ b/handoff/patterns/api-gateway-workflow/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "api-gateway-workflow", + "workflow_id": "api-gateway", + "title": "Api Gateway Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "handoff", + "secondary_use_cases": [ + "security", + "mcp" + ], + "use_cases": [ + "handoff", + "security", + "mcp" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "api-gateway", + "microservices", + "rate-limiting", + "request-routing", + "authentication", + "load-balancing" + ], + "description": "API Gateway pattern with request authentication, rate limiting, request routing to backend services, response aggregation, and error handling.", + "source_path": "patterns/api-gateway", + "repo_path": "handoff/patterns/api-gateway-workflow" +} diff --git a/handoff/patterns/api-gateway-workflow/workflow.fz b/handoff/patterns/api-gateway-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..918d6ef86e76ba782f31a3efe0b17acb66b33d0e --- /dev/null +++ b/handoff/patterns/api-gateway-workflow/workflow.fz @@ -0,0 +1,44 @@ +Client { # Client +n1: circle label:"Start" +n2: rectangle label:"Send API request" +n3: rectangle label:"Receive response" +n4: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Gateway.n5.handle(top) [label="HTTP Request"] +n3.handle(right) -> n4.handle(left) +} +Gateway { # API Gateway +n5: rectangle label:"Receive incoming request" +n6: rectangle label:"Validate API key" +n7: diamond label:"Authenticated?" +n8: rectangle label:"Check rate limits" +n9: rectangle label:"Return 401 Unauthorized" +n10: diamond label:"Within rate limit?" +n11: rectangle label:"Route to service" +n12: rectangle label:"Return 429 Too Many Requests" +n13: rectangle label:"Transform response" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(bottom) -> n9.handle(top) [label="No"] +n8.handle(right) -> n10.handle(left) +n9.handle(top) -> Client.n3.handle(bottom) [label="401"] +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n12.handle(top) [label="No"] +n11.handle(bottom) -> Backend.n14.handle(top) [label="Forward"] +n12.handle(top) -> Client.n3.handle(bottom) [label="429"] +n13.handle(top) -> Client.n3.handle(bottom) [label="Response"] +} +Backend { # Backend Service +n14: rectangle label:"Process request" +n15: diamond label:"Request valid?" +n16: rectangle label:"Execute business logic" +n17: rectangle label:"Return error response" +n18: rectangle label:"Return success response" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(right) -> n18.handle(left) +n17.handle(top) -> Gateway.n13.handle(bottom) [label="Error"] +n18.handle(top) -> Gateway.n13.handle(bottom) [label="Success"] +} diff --git a/handoff/patterns/escalation-pattern-workflow/README.md b/handoff/patterns/escalation-pattern-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..52a4d9ea143585930b270b87d6fa07e75a106d73 --- /dev/null +++ b/handoff/patterns/escalation-pattern-workflow/README.md @@ -0,0 +1,19 @@ +# Escalation Pattern Workflow + +This workflow models escalating issues to higher authority when needed. + +**Template ID:** `escalation-pattern-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [escalation, pattern, patterns] +**Source path:** `patterns/escalation-pattern` +**Repo path:** `handoff/patterns/escalation-pattern-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/patterns/escalation-pattern-workflow/metadata.json b/handoff/patterns/escalation-pattern-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3b73435bd5d059fabd8f7495fffa927af133fda8 --- /dev/null +++ b/handoff/patterns/escalation-pattern-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "escalation-pattern-workflow", + "workflow_id": "escalation-pattern", + "title": "Escalation Pattern Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "escalation", + "pattern", + "patterns" + ], + "description": "This workflow models escalating issues to higher authority when needed.", + "source_path": "patterns/escalation-pattern", + "repo_path": "handoff/patterns/escalation-pattern-workflow" +} diff --git a/handoff/patterns/escalation-pattern-workflow/workflow.fz b/handoff/patterns/escalation-pattern-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ed93834e42dfd379da68eb693bfcc83089bdf74c --- /dev/null +++ b/handoff/patterns/escalation-pattern-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Escalation Pattern" + n4: rectangle label:"Execute Escalation Pattern action" + n7: rectangle label:"Monitor Escalation Pattern status" + n10: circle label:"End Escalation Pattern" + n1.handle(bottom) -> app.n2.handle(top) + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) +} + +app { # App + n2: rectangle label:"Receive Escalation Pattern event" + n5: rectangle label:"Record Escalation Pattern outcome" + n8: rectangle label:"Monitor Escalation Pattern status" + n2.handle(bottom) -> service.n3.handle(top) + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Escalation Pattern conditions" + n6: rectangle label:"Monitor Escalation Pattern status" + n9: diamond label:"Monitor Escalation Pattern status" + n3.handle(right) -> user.n4.handle(left) [label="Processed"] + n9.handle(left) -> app.n8.handle(left) [label="Retry/Rejected"] + n9.handle(right) -> user.n10.handle(bottom) [label="Valid"] + n6.handle(right) -> user.n7.handle(left) [label="Success"] +} diff --git a/handoff/patterns/routing-slip-workflow/README.md b/handoff/patterns/routing-slip-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..46b7d74d54985286882b6063a15f390f757e8c6a --- /dev/null +++ b/handoff/patterns/routing-slip-workflow/README.md @@ -0,0 +1,19 @@ +# Routing Slip Workflow + +This workflow models having messages carry their own routing instructions. + +**Template ID:** `routing-slip-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** handoff +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [routing, slip, patterns] +**Source path:** `patterns/routing-slip` +**Repo path:** `handoff/patterns/routing-slip-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/handoff/patterns/routing-slip-workflow/metadata.json b/handoff/patterns/routing-slip-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..736c4cac486eea8517fd882eba4679d90094bf7f --- /dev/null +++ b/handoff/patterns/routing-slip-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "routing-slip-workflow", + "workflow_id": "routing-slip", + "title": "Routing Slip Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "handoff", + "secondary_use_cases": [], + "use_cases": [ + "handoff" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "routing", + "slip", + "patterns" + ], + "description": "This workflow models having messages carry their own routing instructions.", + "source_path": "patterns/routing-slip", + "repo_path": "handoff/patterns/routing-slip-workflow" +} diff --git a/handoff/patterns/routing-slip-workflow/workflow.fz b/handoff/patterns/routing-slip-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0b9615ee72bfd217cb7ea2fd2e6b25454d2d696d --- /dev/null +++ b/handoff/patterns/routing-slip-workflow/workflow.fz @@ -0,0 +1,38 @@ +user { # User + n1: circle label:"Start Routing Slip" + n5: rectangle label:"Record Routing Slip outcome" + n9: rectangle label:"Monitor Routing Slip status" + n13: circle label:"End Routing Slip" + n1.handle(bottom) -> app.n2.handle(top) + n5.handle(bottom) -> app.n6.handle(top) [label="Done"] + n9.handle(bottom) -> app.n10.handle(top) +} + +app { # App + n2: rectangle label:"Receive Routing Slip event" + n6: rectangle label:"Monitor Routing Slip status" + n10: rectangle label:"Monitor Routing Slip status" + n2.handle(bottom) -> service.n3.handle(top) [label="Next"] + n6.handle(bottom) -> service.n7.handle(top) + n10.handle(bottom) -> service.n11.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Routing Slip conditions" + n7: rectangle label:"Monitor Routing Slip status" + n11: rectangle label:"Monitor Routing Slip status" + n3.handle(bottom) -> database.n4.handle(top) + n7.handle(bottom) -> database.n8.handle(top) + n11.handle(bottom) -> database.n12.handle(top) [label="Success"] +} + +database { # Database + n4: diamond label:"Execute Routing Slip action" + n8: rectangle label:"Monitor Routing Slip status" + n12: diamond label:"Monitor Routing Slip status" + n12.handle(left) -> service.n11.handle(left) [label="Retry/Rejected"] + n12.handle(right) -> user.n13.handle(bottom) + n8.handle(right) -> user.n9.handle(left) [label="Processed"] + n4.handle(left) -> service.n3.handle(left) [label="Retry/Rejected"] + n4.handle(right) -> user.n5.handle(left) +} diff --git a/incident/architecture/api-composition-pattern-architecture/README.md b/incident/architecture/api-composition-pattern-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1c109016a117199e972b3bb23ed2cf5305d93c9e --- /dev/null +++ b/incident/architecture/api-composition-pattern-architecture/README.md @@ -0,0 +1,19 @@ +# API Composition Pattern Architecture + +An API composition architecture diagram with a composer service that fans out parallel requests to multiple microservices, collects responses with timeout handling, and merges results into a single unified response with partial fallback support. This template models the API composition pattern used when a single client query requires data from multiple services, avoiding the need for direct service-to-service calls. Useful for teams building aggregation layers in microservices architectures. + +**Template ID:** `api-composition-pattern-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** incident +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 16 +**Lanes:** 3 +**Tags:** [api-composition, response-aggregation, fan-out, parallel-requests, timeout-handling, partial-response, microservices, architecture-diagram] +**Source path:** `` +**Repo path:** `incident/architecture/api-composition-pattern-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/architecture/api-composition-pattern-architecture/metadata.json b/incident/architecture/api-composition-pattern-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f0c57f4032d8740d909e058c678fcbe7c67a3036 --- /dev/null +++ b/incident/architecture/api-composition-pattern-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "api-composition-pattern-architecture", + "workflow_id": "api-composition-pattern-architecture", + "title": "API Composition Pattern Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "incident", + "secondary_use_cases": [], + "use_cases": [ + "incident" + ], + "complexity": 3, + "num_nodes": 16, + "num_lanes": 3, + "tags": [ + "api-composition", + "response-aggregation", + "fan-out", + "parallel-requests", + "timeout-handling", + "partial-response", + "microservices", + "architecture-diagram" + ], + "description": "An API composition architecture diagram with a composer service that fans out parallel requests to multiple microservices, collects responses with timeout handling, and merges results into a single unified response with partial fallback support. This template models the API composition pattern used when a single client query requires data from multiple services, avoiding the need for direct service-to-service calls. Useful for teams building aggregation layers in microservices architectures.", + "source_path": "", + "repo_path": "incident/architecture/api-composition-pattern-architecture" +} diff --git a/incident/architecture/api-composition-pattern-architecture/workflow.fz b/incident/architecture/api-composition-pattern-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..7ead7012e8cc86210c17e05cbb3910d401d02eff --- /dev/null +++ b/incident/architecture/api-composition-pattern-architecture/workflow.fz @@ -0,0 +1,44 @@ +Client { # Client Application +n1: circle label:"Complex Query Request" +n2: rectangle label:"API Composer Service" +n19: rectangle label:"Receive Composed Response" +n20: circle label:"Display Result" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Composer.n3.handle(top) [label="Compose"] +n19.handle(right) -> n20.handle(left) +} +Composer { # API Composition Layer +n3: rectangle label:"Parse Query Requirements" +n4: rectangle label:"Fan-Out Parallel Requests" +n13: rectangle label:"Collect Responses" +n14: diamond label:"All Responses Received?" +n15: rectangle label:"Merge and Transform" +n16: rectangle label:"Return Partial with Fallback" +n3.handle(right) -> n4.handle(left) [label="Decompose"] +n4.handle(bottom) -> Services.n5.handle(top) [label="GET /users"] +n4.handle(bottom) -> Services.n7.handle(top) [label="GET /orders"] +n4.handle(bottom) -> Services.n9.handle(top) [label="GET /products"] +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Yes"] +n14.handle(bottom) -> n16.handle(top) [label="Timeout"] +n15.handle(top) -> Client.n19.handle(bottom) [label="Composed JSON"] +n16.handle(top) -> Client.n19.handle(bottom) [label="Partial JSON"] +} +Services { # Microservices +n5: rectangle label:"User Service" +n6: rectangle label:"User Response" +n7: rectangle label:"Order Service" +n8: rectangle label:"Order Response" +n9: rectangle label:"Product Service" +n10: rectangle label:"Product Response" +n11: rectangle label:"Aggregate Results" +n12: rectangle label:"Send to Composer" +n5.handle(right) -> n6.handle(left) [label="Query"] +n7.handle(right) -> n8.handle(left) [label="Query"] +n9.handle(right) -> n10.handle(left) [label="Query"] +n6.handle(bottom) -> n11.handle(top) [label="User Data"] +n8.handle(bottom) -> n11.handle(top) [label="Order Data"] +n10.handle(right) -> n11.handle(left) [label="Product Data"] +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> Composer.n13.handle(bottom) [label="All Data"] +} diff --git a/incident/architecture/event-driven-dead-letter-queue-architecture/README.md b/incident/architecture/event-driven-dead-letter-queue-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3c262780084307ddc99868d71434bb44fd8f0de2 --- /dev/null +++ b/incident/architecture/event-driven-dead-letter-queue-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven Dead Letter Queue Architecture + +A dead letter queue architecture diagram with retry policies, exponential backoff, max retry thresholds, DLQ routing for failed messages, operations alerting, and manual reprocessing workflows. This template models the critical error handling pattern for asynchronous messaging systems, ensuring no message is silently lost when processing fails. Essential for building reliable event-driven systems with proper failure recovery mechanisms. + +**Template ID:** `event-driven-dead-letter-queue-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** incident +**Secondary use cases:** compliance +**Complexity:** 3/5 +**Nodes:** 16 +**Lanes:** 3 +**Tags:** [dead-letter-queue, dlq, retry-policy, message-processing, error-handling, operations-alerting, message-reliability, architecture-diagram] +**Source path:** `` +**Repo path:** `incident/architecture/event-driven-dead-letter-queue-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/architecture/event-driven-dead-letter-queue-architecture/metadata.json b/incident/architecture/event-driven-dead-letter-queue-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6dc8e79678d51ff1b55374a7a00ba2efbc5a09b6 --- /dev/null +++ b/incident/architecture/event-driven-dead-letter-queue-architecture/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "event-driven-dead-letter-queue-architecture", + "workflow_id": "event-driven-dead-letter-queue-architecture", + "title": "Event-Driven Dead Letter Queue Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "incident", + "secondary_use_cases": [ + "compliance" + ], + "use_cases": [ + "incident", + "compliance" + ], + "complexity": 3, + "num_nodes": 16, + "num_lanes": 3, + "tags": [ + "dead-letter-queue", + "dlq", + "retry-policy", + "message-processing", + "error-handling", + "operations-alerting", + "message-reliability", + "architecture-diagram" + ], + "description": "A dead letter queue architecture diagram with retry policies, exponential backoff, max retry thresholds, DLQ routing for failed messages, operations alerting, and manual reprocessing workflows. This template models the critical error handling pattern for asynchronous messaging systems, ensuring no message is silently lost when processing fails. Essential for building reliable event-driven systems with proper failure recovery mechanisms.", + "source_path": "", + "repo_path": "incident/architecture/event-driven-dead-letter-queue-architecture" +} diff --git a/incident/architecture/event-driven-dead-letter-queue-architecture/workflow.fz b/incident/architecture/event-driven-dead-letter-queue-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..dd65e31c5df35be9c337ce5fc8e3f54c6ae79004 --- /dev/null +++ b/incident/architecture/event-driven-dead-letter-queue-architecture/workflow.fz @@ -0,0 +1,39 @@ +Producer { # Message Producer +n1: circle label:"Publish Message" +n2: rectangle label:"Serialize Payload" +n3: rectangle label:"Send to Main Queue" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Enqueue"] +n3.handle(bottom) -> MainQueue.n4.handle(top) [label="Deliver"] +} +MainQueue { # Main Processing Queue +n4: rectangle label:"Receive Message" +n5: rectangle label:"Attempt Processing" +n6: diamond label:"Processing Succeeded?" +n7: rectangle label:"Acknowledge Message" +n8: rectangle label:"Increment Retry Count" +n9: diamond label:"Max Retries Exceeded?" +n10: rectangle label:"Schedule Retry" +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) [label="Yes"] +n6.handle(bottom) -> n8.handle(top) [label="No"] +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Retry"] +n9.handle(bottom) -> DLQ.n11.handle(top) [label="Exceeded"] +} +DLQ { # Dead Letter Queue +n11: rectangle label:"Route to DLQ" +n12: rectangle label:"Store Failed Message" +n13: rectangle label:"Alert Operations Team" +n14: rectangle label:"Manual Review Dashboard" +n15: diamond label:"Reprocessable?" +n16: rectangle label:"Requeue to Main" +n17: rectangle label:"Archive and Close" +n11.handle(right) -> n12.handle(left) [label="Preserve Context"] +n12.handle(right) -> n13.handle(left) [label="PagerDuty"] +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Investigate"] +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +} diff --git a/incident/architecture/health-check-pattern-architecture/README.md b/incident/architecture/health-check-pattern-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..89b1c8331106049b8b20d6f8c063141a3cf1dca1 --- /dev/null +++ b/incident/architecture/health-check-pattern-architecture/README.md @@ -0,0 +1,19 @@ +# Health Check Pattern Architecture + +A health check pattern architecture diagram with load balancer probes, deep health checks verifying database, cache, disk, and dependency status, automatic instance rotation, and alerting integration with PagerDuty for consecutive failures. This template models the health monitoring infrastructure that enables self-healing systems, where unhealthy instances are automatically removed from rotation and operations teams are alerted. Key for building production-ready services with proper observability. + +**Template ID:** `health-check-pattern-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** incident +**Secondary use cases:** security +**Complexity:** 3/5 +**Nodes:** 19 +**Lanes:** 4 +**Tags:** [health-check, load-balancer, self-healing, monitoring, pagerduty, instance-rotation, deep-health-check, architecture-diagram] +**Source path:** `` +**Repo path:** `incident/architecture/health-check-pattern-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/architecture/health-check-pattern-architecture/metadata.json b/incident/architecture/health-check-pattern-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b2a43b3809d453274e562afef40873ba66ffcaaa --- /dev/null +++ b/incident/architecture/health-check-pattern-architecture/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "health-check-pattern-architecture", + "workflow_id": "health-check-pattern-architecture", + "title": "Health Check Pattern Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "incident", + "secondary_use_cases": [ + "security" + ], + "use_cases": [ + "incident", + "security" + ], + "complexity": 3, + "num_nodes": 19, + "num_lanes": 4, + "tags": [ + "health-check", + "load-balancer", + "self-healing", + "monitoring", + "pagerduty", + "instance-rotation", + "deep-health-check", + "architecture-diagram" + ], + "description": "A health check pattern architecture diagram with load balancer probes, deep health checks verifying database, cache, disk, and dependency status, automatic instance rotation, and alerting integration with PagerDuty for consecutive failures. This template models the health monitoring infrastructure that enables self-healing systems, where unhealthy instances are automatically removed from rotation and operations teams are alerted. Key for building production-ready services with proper observability.", + "source_path": "", + "repo_path": "incident/architecture/health-check-pattern-architecture" +} diff --git a/incident/architecture/health-check-pattern-architecture/workflow.fz b/incident/architecture/health-check-pattern-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..4716ed83bfc46cb2c7c60965a2cda5a582194ae7 --- /dev/null +++ b/incident/architecture/health-check-pattern-architecture/workflow.fz @@ -0,0 +1,59 @@ +LoadBalancer { # Load Balancer +n1: circle label:"Health Check Timer" +n2: rectangle label:"Send Health Probe" +n17: rectangle label:"Evaluate Response" +n18: diamond label:"Instance Healthy?" +n19: rectangle label:"Keep in Rotation" +n20: rectangle label:"Remove from Rotation" +n21: rectangle label:"Update Routing Table" +n1.handle(right) -> n2.handle(left) [label="Every 10s"] +n2.handle(bottom) -> ServiceA.n3.handle(top) [label="GET /health"] +n2.handle(bottom) -> ServiceB.n10.handle(top) [label="GET /health"] +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="200 OK"] +n18.handle(bottom) -> n20.handle(top) [label="Timeout/5xx"] +n19.handle(right) -> n21.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(bottom) -> Alerting.n22.handle(top) [label="Status Change"] +} +ServiceA { # Service A +n3: rectangle label:"Check Database Connection" +n4: rectangle label:"Check Redis Connection" +n5: rectangle label:"Check Disk Space" +n6: rectangle label:"Return Health Status" +n7: rectangle label:"Send Status to LB" +n8: rectangle label:"Forward Service A Status" +n9: rectangle label:"Deliver A Result" +n3.handle(right) -> n4.handle(left) [label="DB OK"] +n4.handle(right) -> n5.handle(left) [label="Cache OK"] +n5.handle(right) -> n6.handle(left) [label="Disk OK"] +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(top) -> LoadBalancer.n17.handle(bottom) [label="Status JSON"] +} +ServiceB { # Service B +n10: rectangle label:"Check API Dependencies" +n11: rectangle label:"Check Message Queue" +n12: rectangle label:"Check Memory Usage" +n13: rectangle label:"Return Health Status" +n14: rectangle label:"Send Status to LB" +n15: rectangle label:"Forward Service B Status" +n16: rectangle label:"Deliver B Result" +n10.handle(right) -> n11.handle(left) [label="APIs OK"] +n11.handle(right) -> n12.handle(left) [label="Queue OK"] +n12.handle(right) -> n13.handle(left) [label="Disk OK"] +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(top) -> LoadBalancer.n17.handle(bottom) [label="Status JSON"] +} +Alerting { # Alerting System +n22: rectangle label:"Monitor Health Trends" +n23: diamond label:"Consecutive Failures?" +n24: rectangle label:"Send PagerDuty Alert" +n25: rectangle label:"Log Health Metric" +n22.handle(right) -> n23.handle(left) +n23.handle(right) -> n24.handle(left) [label="3+ Failures"] +n23.handle(bottom) -> n25.handle(top) [label="Below Threshold"] +} diff --git a/incident/architecture/serverless-step-functions-orchestration-architecture/README.md b/incident/architecture/serverless-step-functions-orchestration-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6674cdfe4dbb66469a073c90cad7f10a6a0686b5 --- /dev/null +++ b/incident/architecture/serverless-step-functions-orchestration-architecture/README.md @@ -0,0 +1,19 @@ +# Serverless Step Functions Orchestration Architecture + +An AWS Step Functions orchestration architecture diagram with state machine workflows including choice states, parallel processing, wait-for-callback patterns, and compensation rollback for failed steps. This template models serverless workflow orchestration where complex multi-step processes are defined as state machines with built-in error handling and retry logic. Critical for teams building reliable serverless workflows that require human approval or long-running processes. + +**Template ID:** `serverless-step-functions-orchestration-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** incident +**Secondary use cases:** ai-orchestration +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 3 +**Tags:** [step-functions, serverless-orchestration, state-machine, workflow-automation, callback-pattern, compensation, aws, architecture-diagram] +**Source path:** `` +**Repo path:** `incident/architecture/serverless-step-functions-orchestration-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/architecture/serverless-step-functions-orchestration-architecture/metadata.json b/incident/architecture/serverless-step-functions-orchestration-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..49f5b3986ca30e026cf7dd3d3d836757394aae91 --- /dev/null +++ b/incident/architecture/serverless-step-functions-orchestration-architecture/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "serverless-step-functions-orchestration-architecture", + "workflow_id": "serverless-step-functions-orchestration-architecture", + "title": "Serverless Step Functions Orchestration Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "incident", + "secondary_use_cases": [ + "ai-orchestration" + ], + "use_cases": [ + "incident", + "ai-orchestration" + ], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 3, + "tags": [ + "step-functions", + "serverless-orchestration", + "state-machine", + "workflow-automation", + "callback-pattern", + "compensation", + "aws", + "architecture-diagram" + ], + "description": "An AWS Step Functions orchestration architecture diagram with state machine workflows including choice states, parallel processing, wait-for-callback patterns, and compensation rollback for failed steps. This template models serverless workflow orchestration where complex multi-step processes are defined as state machines with built-in error handling and retry logic. Critical for teams building reliable serverless workflows that require human approval or long-running processes.", + "source_path": "", + "repo_path": "incident/architecture/serverless-step-functions-orchestration-architecture" +} diff --git a/incident/architecture/serverless-step-functions-orchestration-architecture/workflow.fz b/incident/architecture/serverless-step-functions-orchestration-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..808bfdd3bc0dad79217f0a03425725a019de3561 --- /dev/null +++ b/incident/architecture/serverless-step-functions-orchestration-architecture/workflow.fz @@ -0,0 +1,53 @@ +Trigger { # Trigger +n1: circle label:"Start Execution" +n2: rectangle label:"API Gateway / EventBridge" +n3: rectangle label:"Invoke Step Function" +n22: rectangle label:"Receive Execution Result" +n23: circle label:"Execution Complete" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="StartExecution"] +n3.handle(bottom) -> StateMachine.n4.handle(top) [label="Input JSON"] +n22.handle(right) -> n23.handle(left) +} +StateMachine { # AWS Step Functions +n4: rectangle label:"Validate Input (Task)" +n5: diamond label:"Order Type?" +n6: rectangle label:"Standard Order Path" +n7: rectangle label:"Express Order Path" +n8: rectangle label:"Parallel Processing" +n20: rectangle label:"Receive Lambda Results" +n9: rectangle label:"Wait for Approval" +n10: diamond label:"Approved?" +n11: rectangle label:"Execute Final Step" +n12: rectangle label:"Compensation Rollback" +n13: rectangle label:"Report to Trigger" +n21: rectangle label:"Send Execution Result" +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) [label="Standard"] +n5.handle(bottom) -> n7.handle(top) [label="Express"] +n6.handle(right) -> n8.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(bottom) -> Lambdas.n14.handle(top) [label="Invoke"] +n20.handle(right) -> n9.handle(left) [label="Map State"] +n9.handle(right) -> n10.handle(left) [label="Callback"] +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n12.handle(top) [label="No"] +n11.handle(right) -> n13.handle(left) +n12.handle(right) -> n13.handle(left) [label="Rolled Back"] +n13.handle(right) -> n21.handle(left) +n21.handle(top) -> Trigger.n22.handle(bottom) [label="Result"] +} +Lambdas { # Lambda Functions +n14: rectangle label:"Payment Lambda" +n15: rectangle label:"Inventory Lambda" +n16: rectangle label:"Notification Lambda" +n17: rectangle label:"Error Catcher Lambda" +n18: rectangle label:"Collect Lambda Results" +n19: rectangle label:"Return to State Machine" +n14.handle(right) -> n15.handle(left) [label="Charge"] +n15.handle(right) -> n16.handle(left) [label="Reserve"] +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> StateMachine.n20.handle(bottom) [label="Lambda Results"] +} diff --git a/incident/devops/deployment-rollback-workflow/README.md b/incident/devops/deployment-rollback-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..edcdedbb43b46ebdfa32e3e6e5c9589ac4fc72a0 --- /dev/null +++ b/incident/devops/deployment-rollback-workflow/README.md @@ -0,0 +1,19 @@ +# Deployment Rollback Workflow + +Deployment rollback workflow with issue detection, rollback decision, previous version restoration, health verification, and post-mortem documentation. + +**Template ID:** `deployment-rollback-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** incident +**Secondary use cases:** delivery +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [deployment-rollback, version-revert, incident-response, kubernetes, helm-rollback, service-recovery] +**Source path:** `devops/deployment-rollback` +**Repo path:** `incident/devops/deployment-rollback-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/devops/deployment-rollback-workflow/metadata.json b/incident/devops/deployment-rollback-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d06f60d85e924d996a1ffd3c5316319f68c8e09c --- /dev/null +++ b/incident/devops/deployment-rollback-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "deployment-rollback-workflow", + "workflow_id": "deployment-rollback", + "title": "Deployment Rollback Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "incident", + "secondary_use_cases": [ + "delivery" + ], + "use_cases": [ + "incident", + "delivery" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "deployment-rollback", + "version-revert", + "incident-response", + "kubernetes", + "helm-rollback", + "service-recovery" + ], + "description": "Deployment rollback workflow with issue detection, rollback decision, previous version restoration, health verification, and post-mortem documentation.", + "source_path": "devops/deployment-rollback", + "repo_path": "incident/devops/deployment-rollback-workflow" +} diff --git a/incident/devops/deployment-rollback-workflow/workflow.fz b/incident/devops/deployment-rollback-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c0ecd75fe653b00a2d9d16df398fdafccd272618 --- /dev/null +++ b/incident/devops/deployment-rollback-workflow/workflow.fz @@ -0,0 +1,52 @@ +AlertSystem { # Alert System +n1: circle label:"Start" +n2: rectangle label:"Detect anomaly in metrics" +n3: rectangle label:"Trigger rollback alert" +n4: rectangle label:"Notify on-call engineer" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Orchestrator.n6.handle(top) [label="Initiate rollback"] +n4.handle(right) -> n5.handle(left) +} +Orchestrator { # Deployment Orchestrator +n6: rectangle label:"Identify current version" +n7: rectangle label:"Fetch previous stable version" +n8: diamond label:"Previous version available?" +n9: rectangle label:"Prepare rollback manifest" +n10: rectangle label:"Halt manual rollback" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(bottom) -> Kubernetes.n11.handle(top) [label="Apply"] +n10.handle(top) -> AlertSystem.n4.handle(bottom) [label="Manual needed"] +} +Kubernetes { # Kubernetes Cluster +n11: rectangle label:"Scale down new pods" +n12: rectangle label:"Deploy previous image" +n13: rectangle label:"Wait for pods ready" +n14: diamond label:"All pods healthy?" +n15: rectangle label:"Update service selector" +n16: rectangle label:"Mark rollback failed" +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Yes"] +n14.handle(bottom) -> n16.handle(top) [label="No"] +n15.handle(bottom) -> Verification.n17.handle(top) [label="Traffic shifted"] +n16.handle(top) -> AlertSystem.n4.handle(bottom) [label="Failed"] +} +Verification { # Verification +n17: rectangle label:"Run smoke tests" +n18: diamond label:"Tests passing?" +n19: rectangle label:"Update deployment status" +n20: rectangle label:"Cleanup old resources" +n21: rectangle label:"Escalate to team lead" +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Yes"] +n18.handle(bottom) -> n21.handle(top) [label="No"] +n19.handle(right) -> n20.handle(left) +n20.handle(top) -> AlertSystem.n4.handle(bottom) [label="Rollback complete"] +n21.handle(top) -> AlertSystem.n4.handle(bottom) [label="Needs attention"] +} diff --git a/incident/devops/incident-response-workflow/README.md b/incident/devops/incident-response-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..56472e3d8246d0acca870157fc6867412ccc654f --- /dev/null +++ b/incident/devops/incident-response-workflow/README.md @@ -0,0 +1,19 @@ +# Incident Response Workflow + +Production incident response workflow with severity-based routing, war room coordination, incident commander assignment, customer communication, root cause analysis, and postmortem scheduling. + +**Template ID:** `incident-response-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** incident +**Secondary use cases:** None +**Complexity:** 5/5 +**Nodes:** 23 +**Lanes:** 4 +**Tags:** [incident-management, on-call, pagerduty, war-room, severity-levels, postmortem, sre] +**Source path:** `devops/incident-response` +**Repo path:** `incident/devops/incident-response-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/devops/incident-response-workflow/metadata.json b/incident/devops/incident-response-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..96f0cb6cf3994ebd9d47b4cef60924bee1c76da0 --- /dev/null +++ b/incident/devops/incident-response-workflow/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "incident-response-workflow", + "workflow_id": "incident-response", + "title": "Incident Response Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "incident", + "secondary_use_cases": [], + "use_cases": [ + "incident" + ], + "complexity": 5, + "num_nodes": 23, + "num_lanes": 4, + "tags": [ + "incident-management", + "on-call", + "pagerduty", + "war-room", + "severity-levels", + "postmortem", + "sre" + ], + "description": "Production incident response workflow with severity-based routing, war room coordination, incident commander assignment, customer communication, root cause analysis, and postmortem scheduling.", + "source_path": "devops/incident-response", + "repo_path": "incident/devops/incident-response-workflow" +} diff --git a/incident/devops/incident-response-workflow/workflow.fz b/incident/devops/incident-response-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..930bee544df85d9adaf13e813fe7de407b86ce79 --- /dev/null +++ b/incident/devops/incident-response-workflow/workflow.fz @@ -0,0 +1,56 @@ +Monitoring { # Monitoring System +n1: circle label:"Start" +n2: rectangle label:"Alert triggered" +n3: rectangle label:"Page on-call responder" +n4: rectangle label:"Log incident timeline" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> OnCall.n6.handle(top) [label="SEV-1 Alert"] +n3.handle(bottom) -> OnCall.n6.handle(top) [label="Paged"] +n4.handle(right) -> n5.handle(left) +} +OnCall { # On-Call Responder +n6: rectangle label:"Acknowledge incident" +n7: rectangle label:"Assess severity and impact" +n8: diamond label:"Severity level?" +n9: rectangle label:"Declare major incident" +n10: rectangle label:"Begin troubleshooting" +n11: rectangle label:"Escalate to team lead" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="SEV-1/2"] +n8.handle(bottom) -> n10.handle(top) [label="SEV-3/4"] +n9.handle(bottom) -> IncidentCommand.n12.handle(top) [label="Open bridge"] +n10.handle(bottom) -> Resolution.n18.handle(top) [label="Investigate"] +n11.handle(bottom) -> IncidentCommand.n12.handle(top) [label="Needs help"] +} +IncidentCommand { # Incident Command +n12: rectangle label:"Open war room bridge" +n13: rectangle label:"Assign incident commander" +n14: rectangle label:"Coordinate response teams" +n15: rectangle label:"Communicate status updates" +n16: diamond label:"Customer impact?" +n17: rectangle label:"Notify customer success" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> Resolution.n18.handle(top) [label="No"] +n17.handle(bottom) -> Resolution.n18.handle(top) [label="Notified"] +} +Resolution { # Resolution +n18: rectangle label:"Identify root cause" +n19: rectangle label:"Implement fix" +n20: diamond label:"Issue resolved?" +n21: rectangle label:"Verify recovery" +n22: rectangle label:"Close incident" +n23: rectangle label:"Schedule postmortem" +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) [label="Yes"] +n20.handle(bottom) -> n18.handle(bottom) [label="No - Continue"] +n21.handle(right) -> n22.handle(left) +n22.handle(right) -> n23.handle(left) +n23.handle(top) -> Monitoring.n4.handle(bottom) [label="Complete"] +} diff --git a/incident/devops/monitoring-alert-workflow/README.md b/incident/devops/monitoring-alert-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b169c99ee83b6cd24315ef7777672217e9546eae --- /dev/null +++ b/incident/devops/monitoring-alert-workflow/README.md @@ -0,0 +1,19 @@ +# Monitoring Alert Workflow + +Monitoring and alerting workflow with metric collection, threshold evaluation, alert routing, escalation policies, and incident creation. + +**Template ID:** `monitoring-alert-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** incident +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [monitoring-alerting, prometheus, pagerduty, threshold-alerts, anomaly-detection, on-call] +**Source path:** `devops/monitoring-alert` +**Repo path:** `incident/devops/monitoring-alert-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/devops/monitoring-alert-workflow/metadata.json b/incident/devops/monitoring-alert-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..a1612c504e43d129c77e7cf90375c3c95e0c5e88 --- /dev/null +++ b/incident/devops/monitoring-alert-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "monitoring-alert-workflow", + "workflow_id": "monitoring-alert", + "title": "Monitoring Alert Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "incident", + "secondary_use_cases": [], + "use_cases": [ + "incident" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "monitoring-alerting", + "prometheus", + "pagerduty", + "threshold-alerts", + "anomaly-detection", + "on-call" + ], + "description": "Monitoring and alerting workflow with metric collection, threshold evaluation, alert routing, escalation policies, and incident creation.", + "source_path": "devops/monitoring-alert", + "repo_path": "incident/devops/monitoring-alert-workflow" +} diff --git a/incident/devops/monitoring-alert-workflow/workflow.fz b/incident/devops/monitoring-alert-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e1639b319920f291066fc151ae03de1168a163b7 --- /dev/null +++ b/incident/devops/monitoring-alert-workflow/workflow.fz @@ -0,0 +1,45 @@ +Prometheus { # Prometheus +n1: circle label:"Start" +n2: rectangle label:"Scrape metrics endpoint" +n3: rectangle label:"Evaluate alert rules" +n4: diamond label:"Threshold breached?" +n5: rectangle label:"Fire alert to Alertmanager" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="Yes"] +n4.handle(bottom) -> n6.handle(top) [label="No"] +n5.handle(bottom) -> Alertmanager.n7.handle(top) [label="Alert fired"] +} +Alertmanager { # Alertmanager +n7: rectangle label:"Receive alert" +n8: rectangle label:"Deduplicate alerts" +n9: rectangle label:"Group related alerts" +n10: diamond label:"Silenced or inhibited?" +n11: rectangle label:"Route to receiver" +n12: rectangle label:"Drop alert" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="No"] +n10.handle(bottom) -> n12.handle(top) [label="Yes"] +n11.handle(bottom) -> Notification.n13.handle(top) [label="Notify"] +n12.handle(top) -> Prometheus.n6.handle(bottom) [label="Suppressed"] +} +Notification { # Notification Channels +n13: rectangle label:"Format alert message" +n14: diamond label:"Channel type?" +n15: rectangle label:"Send to Slack" +n16: rectangle label:"Send to PagerDuty" +n17: rectangle label:"Send email" +n18: rectangle label:"Log delivery status" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Slack"] +n14.handle(bottom) -> n16.handle(top) [label="PagerDuty"] +n14.handle(left) -> n17.handle(top) [label="Email"] +n15.handle(bottom) -> n18.handle(top) +n16.handle(right) -> n18.handle(left) +n17.handle(bottom) -> n18.handle(left) +n18.handle(top) -> Prometheus.n6.handle(bottom) [label="Delivered"] +} diff --git a/incident/logistics/cold-chain-monitoring-workflow/README.md b/incident/logistics/cold-chain-monitoring-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b555040c4ae48e14af6b7bf61648032ac8c5c074 --- /dev/null +++ b/incident/logistics/cold-chain-monitoring-workflow/README.md @@ -0,0 +1,19 @@ +# Cold Chain Monitoring Workflow + +Cold chain monitoring workflow with IoT temperature sensors, real-time alerts, excursion documentation, corrective action triggers, and compliance reporting. + +**Template ID:** `cold-chain-monitoring-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** incident +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [cold-chain, temperature-monitoring, iot-sensors, excursion-alert, pharmaceutical, perishables] +**Source path:** `logistics/cold-chain-monitoring` +**Repo path:** `incident/logistics/cold-chain-monitoring-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/logistics/cold-chain-monitoring-workflow/metadata.json b/incident/logistics/cold-chain-monitoring-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d8a3b6f52871a26fce086ae25c18bf7835dad727 --- /dev/null +++ b/incident/logistics/cold-chain-monitoring-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "cold-chain-monitoring-workflow", + "workflow_id": "cold-chain-monitoring", + "title": "Cold Chain Monitoring Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "incident", + "secondary_use_cases": [], + "use_cases": [ + "incident" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "cold-chain", + "temperature-monitoring", + "iot-sensors", + "excursion-alert", + "pharmaceutical", + "perishables" + ], + "description": "Cold chain monitoring workflow with IoT temperature sensors, real-time alerts, excursion documentation, corrective action triggers, and compliance reporting.", + "source_path": "logistics/cold-chain-monitoring", + "repo_path": "incident/logistics/cold-chain-monitoring-workflow" +} diff --git a/incident/logistics/cold-chain-monitoring-workflow/workflow.fz b/incident/logistics/cold-chain-monitoring-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e49183301a3df03293feb585ef62dad5e990fb26 --- /dev/null +++ b/incident/logistics/cold-chain-monitoring-workflow/workflow.fz @@ -0,0 +1,22 @@ +supplier { # Supplier + n1: circle label:"Start Cold Chain Monitoring" + n3: rectangle label:"Review Cold Chain Monitoring details" + n5: rectangle label:"Update records for Cold Chain Monitoring" + n7: circle label:"End Cold Chain Monitoring" + n1.handle(bottom) -> warehouse.n2.handle(top) + n1.handle(right) -> n3.handle(left) + n1.handle(bottom) -> warehouse.n4.handle(top) + n1.handle(right) -> n5.handle(left) + n1.handle(bottom) -> warehouse.n6.handle(top) + n5.handle(right) -> n7.handle(left) + n3.handle(right) -> n7.handle(top) +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Cold Chain Monitoring request" + n4: rectangle label:"Make Cold Chain Monitoring decision" + n6: diamond label:"Continue Cold Chain Monitoring process" + n6.handle(right) -> supplier.n7.handle(bottom) + n4.handle(right) -> supplier.n7.handle(bottom) + n2.handle(right) -> supplier.n7.handle(bottom) +} diff --git a/incident/logistics/hazmat-handling-workflow/README.md b/incident/logistics/hazmat-handling-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3337785189a979fc7c6ba8665b5ad6c7b4b231af --- /dev/null +++ b/incident/logistics/hazmat-handling-workflow/README.md @@ -0,0 +1,19 @@ +# Hazmat Handling Workflow + +Hazardous materials handling workflow with UN classification, SDS documentation, proper labeling, certified handler assignment, and emergency response procedures. + +**Template ID:** `hazmat-handling-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** incident +**Secondary use cases:** compliance +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [hazmat-handling, dangerous-goods, un-classification, sds-documentation, dot-compliance, emergency-response] +**Source path:** `logistics/hazmat-handling` +**Repo path:** `incident/logistics/hazmat-handling-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/logistics/hazmat-handling-workflow/metadata.json b/incident/logistics/hazmat-handling-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..97ed94b340d6314d48ab3cf549482b489871dbe3 --- /dev/null +++ b/incident/logistics/hazmat-handling-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "hazmat-handling-workflow", + "workflow_id": "hazmat-handling", + "title": "Hazmat Handling Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "incident", + "secondary_use_cases": [ + "compliance" + ], + "use_cases": [ + "incident", + "compliance" + ], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "hazmat-handling", + "dangerous-goods", + "un-classification", + "sds-documentation", + "dot-compliance", + "emergency-response" + ], + "description": "Hazardous materials handling workflow with UN classification, SDS documentation, proper labeling, certified handler assignment, and emergency response procedures.", + "source_path": "logistics/hazmat-handling", + "repo_path": "incident/logistics/hazmat-handling-workflow" +} diff --git a/incident/logistics/hazmat-handling-workflow/workflow.fz b/incident/logistics/hazmat-handling-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..574c151899f34c0d59c8703678c8c86bd5439b8e --- /dev/null +++ b/incident/logistics/hazmat-handling-workflow/workflow.fz @@ -0,0 +1,28 @@ +supplier { # Supplier + n1: circle label:"Start Hazmat Handling" + n2: diamond label:"Receive Hazmat Handling request" + n4: rectangle label:"Make Hazmat Handling decision" + n7: rectangle label:"Continue Hazmat Handling process" + n10: circle label:"End Hazmat Handling" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> iot_sensor.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> warehouse.n5.handle(top) + n7.handle(bottom) -> warehouse.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +warehouse { # Warehouse + n5: rectangle label:"Update records for Hazmat Handling" + n8: rectangle label:"Continue Hazmat Handling process" + n5.handle(bottom) -> iot_sensor.n6.handle(top) + n8.handle(bottom) -> iot_sensor.n9.handle(top) +} + +iot_sensor { # Iot_Sensor + n3: rectangle label:"Review Hazmat Handling details" + n6: rectangle label:"Continue Hazmat Handling process" + n9: rectangle label:"Continue Hazmat Handling process" + n9.handle(right) -> supplier.n10.handle(bottom) + n6.handle(right) -> supplier.n7.handle(left) + n3.handle(left) -> warehouse.n5.handle(left) +} diff --git a/incident/patterns/canary-deploy-workflow/README.md b/incident/patterns/canary-deploy-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9828a44c6b337996fe85322993fcaf0e66d60414 --- /dev/null +++ b/incident/patterns/canary-deploy-workflow/README.md @@ -0,0 +1,19 @@ +# Canary Deploy Workflow + +Canary deployment pattern with gradual traffic shifting, real-time metrics monitoring, automatic rollback triggers, and progressive rollout to full production. + +**Template ID:** `canary-deploy-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** incident +**Secondary use cases:** delivery +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [canary-deployment, progressive-rollout, traffic-splitting, metrics-monitoring, gradual-release, feature-flags] +**Source path:** `patterns/canary-deploy` +**Repo path:** `incident/patterns/canary-deploy-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/incident/patterns/canary-deploy-workflow/metadata.json b/incident/patterns/canary-deploy-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4ced77082dbeb882a4ce483318051f956b669d78 --- /dev/null +++ b/incident/patterns/canary-deploy-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "canary-deploy-workflow", + "workflow_id": "canary-deploy", + "title": "Canary Deploy Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "incident", + "secondary_use_cases": [ + "delivery" + ], + "use_cases": [ + "incident", + "delivery" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "canary-deployment", + "progressive-rollout", + "traffic-splitting", + "metrics-monitoring", + "gradual-release", + "feature-flags" + ], + "description": "Canary deployment pattern with gradual traffic shifting, real-time metrics monitoring, automatic rollback triggers, and progressive rollout to full production.", + "source_path": "patterns/canary-deploy", + "repo_path": "incident/patterns/canary-deploy-workflow" +} diff --git a/incident/patterns/canary-deploy-workflow/workflow.fz b/incident/patterns/canary-deploy-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..38a79115b647dc389f29fe657611a7565f75e582 --- /dev/null +++ b/incident/patterns/canary-deploy-workflow/workflow.fz @@ -0,0 +1,48 @@ +Deployment { # Deployment Pipeline +n1: circle label:"Start" +n2: rectangle label:"Build container image" +n3: rectangle label:"Push to registry" +n4: rectangle label:"Complete rollout" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> CanaryController.n6.handle(top) [label="Deploy canary"] +n4.handle(right) -> n5.handle(left) +} +CanaryController { # Canary Controller +n6: rectangle label:"Deploy to 5% of pods" +n7: rectangle label:"Configure traffic split" +n8: rectangle label:"Wait observation period" +n9: diamond label:"Metrics healthy?" +n10: rectangle label:"Increase to 25%" +n11: rectangle label:"Rollback canary" +n12: diamond label:"Still healthy?" +n13: rectangle label:"Increase to 50%" +n14: rectangle label:"Full rollout 100%" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n11.handle(top) [label="No"] +n10.handle(right) -> n12.handle(left) +n11.handle(top) -> Deployment.n4.handle(bottom) [label="Aborted"] +n12.handle(right) -> n13.handle(left) [label="Yes"] +n12.handle(bottom) -> n11.handle(top) [label="No"] +n13.handle(right) -> n14.handle(left) +n14.handle(bottom) -> Monitoring.n15.handle(top) [label="Monitor"] +} +Monitoring { # Monitoring +n15: rectangle label:"Track error rate" +n16: rectangle label:"Measure latency p99" +n17: rectangle label:"Check resource usage" +n18: diamond label:"All metrics pass?" +n19: rectangle label:"Mark deployment success" +n20: rectangle label:"Trigger automatic rollback" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Yes"] +n18.handle(bottom) -> n20.handle(top) [label="No"] +n19.handle(top) -> Deployment.n4.handle(bottom) [label="Success"] +n20.handle(top) -> Deployment.n4.handle(bottom) [label="Rolled back"] +} diff --git a/mcp/architecture/ambassador-pattern-architecture/README.md b/mcp/architecture/ambassador-pattern-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..cb21d6b644c063183ca35b35f06bc763be5f937b --- /dev/null +++ b/mcp/architecture/ambassador-pattern-architecture/README.md @@ -0,0 +1,19 @@ +# Ambassador Pattern Architecture + +An ambassador pattern architecture diagram with a local proxy sidecar handling authentication header injection, circuit breaking, retry logic, and metrics collection for outbound requests to external third-party APIs. This template models the ambassador pattern where a helper service running alongside the application offloads cross-cutting concerns for external communication. Useful for teams integrating with unreliable third-party services that need resilience wrappers. + +**Template ID:** `ambassador-pattern-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 15 +**Lanes:** 3 +**Tags:** [ambassador-pattern, sidecar-proxy, external-api, retry-logic, circuit-breaker, metrics-collection, cross-cutting-concerns, architecture-diagram] +**Source path:** `` +**Repo path:** `mcp/architecture/ambassador-pattern-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/architecture/ambassador-pattern-architecture/metadata.json b/mcp/architecture/ambassador-pattern-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..76600a152bd0417381e85d4d5a6be17214e41805 --- /dev/null +++ b/mcp/architecture/ambassador-pattern-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "ambassador-pattern-architecture", + "workflow_id": "ambassador-pattern-architecture", + "title": "Ambassador Pattern Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 3, + "num_nodes": 15, + "num_lanes": 3, + "tags": [ + "ambassador-pattern", + "sidecar-proxy", + "external-api", + "retry-logic", + "circuit-breaker", + "metrics-collection", + "cross-cutting-concerns", + "architecture-diagram" + ], + "description": "An ambassador pattern architecture diagram with a local proxy sidecar handling authentication header injection, circuit breaking, retry logic, and metrics collection for outbound requests to external third-party APIs. This template models the ambassador pattern where a helper service running alongside the application offloads cross-cutting concerns for external communication. Useful for teams integrating with unreliable third-party services that need resilience wrappers.", + "source_path": "", + "repo_path": "mcp/architecture/ambassador-pattern-architecture" +} diff --git a/mcp/architecture/ambassador-pattern-architecture/workflow.fz b/mcp/architecture/ambassador-pattern-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3cde1928544601e3ba5f986e52069110a096cec9 --- /dev/null +++ b/mcp/architecture/ambassador-pattern-architecture/workflow.fz @@ -0,0 +1,36 @@ +Application { # Application Container +n1: circle label:"Outbound Request" +n2: rectangle label:"Application Code" +n3: rectangle label:"Ambassador Proxy" +n14: rectangle label:"Receive Proxied Response" +n15: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="localhost:9000"] +n3.handle(bottom) -> AmbassadorLogic.n4.handle(top) [label="Intercept"] +n14.handle(right) -> n15.handle(left) +} +AmbassadorLogic { # Ambassador Logic +n4: rectangle label:"Add Auth Headers" +n5: rectangle label:"Apply Circuit Breaker" +n6: diamond label:"Circuit Open?" +n7: rectangle label:"Enable Retry Logic" +n8: rectangle label:"Return Cached Fallback" +n12: rectangle label:"Collect Metrics" +n13: rectangle label:"Forward Response" +n4.handle(right) -> n5.handle(left) [label="Bearer Token"] +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) [label="Closed"] +n6.handle(bottom) -> n8.handle(top) [label="Open"] +n7.handle(bottom) -> ExternalService.n9.handle(top) [label="HTTPS + Retry"] +n8.handle(top) -> Application.n14.handle(bottom) [label="Fallback"] +n12.handle(right) -> n13.handle(left) +n13.handle(top) -> Application.n14.handle(bottom) [label="Proxied Response"] +} +ExternalService { # External API +n9: rectangle label:"Third-Party API" +n10: rectangle label:"Process Request" +n11: rectangle label:"Return Response" +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(top) -> AmbassadorLogic.n12.handle(bottom) [label="Response + Metrics"] +} diff --git a/mcp/architecture/circuit-breaker-resilience-architecture/README.md b/mcp/architecture/circuit-breaker-resilience-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..010420b597c2ce10ccc29ec2b55e3fbc0e609b69 --- /dev/null +++ b/mcp/architecture/circuit-breaker-resilience-architecture/README.md @@ -0,0 +1,19 @@ +# Circuit Breaker Resilience Architecture + +A circuit breaker resilience architecture diagram showing the complete state machine with closed, open, and half-open states, failure threshold tracking, recovery timer, and fallback response strategies for protecting services from cascading failures. This template visualizes the circuit breaker pattern in detail, including how the breaker transitions between states based on success and failure counts. Essential for building fault-tolerant microservices that degrade gracefully under load. + +**Template ID:** `circuit-breaker-resilience-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 3 +**Tags:** [circuit-breaker, resilience, fault-tolerance, cascading-failure, half-open-state, fallback, state-machine, architecture-diagram] +**Source path:** `` +**Repo path:** `mcp/architecture/circuit-breaker-resilience-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/architecture/circuit-breaker-resilience-architecture/metadata.json b/mcp/architecture/circuit-breaker-resilience-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3f9c9ada8b8329257b639eaad9ea7b58ac9c9375 --- /dev/null +++ b/mcp/architecture/circuit-breaker-resilience-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "circuit-breaker-resilience-architecture", + "workflow_id": "circuit-breaker-resilience-architecture", + "title": "Circuit Breaker Resilience Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 3, + "tags": [ + "circuit-breaker", + "resilience", + "fault-tolerance", + "cascading-failure", + "half-open-state", + "fallback", + "state-machine", + "architecture-diagram" + ], + "description": "A circuit breaker resilience architecture diagram showing the complete state machine with closed, open, and half-open states, failure threshold tracking, recovery timer, and fallback response strategies for protecting services from cascading failures. This template visualizes the circuit breaker pattern in detail, including how the breaker transitions between states based on success and failure counts. Essential for building fault-tolerant microservices that degrade gracefully under load.", + "source_path": "", + "repo_path": "mcp/architecture/circuit-breaker-resilience-architecture" +} diff --git a/mcp/architecture/circuit-breaker-resilience-architecture/workflow.fz b/mcp/architecture/circuit-breaker-resilience-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..bf3619f098da490fb867d4cc93effc07ae48181a --- /dev/null +++ b/mcp/architecture/circuit-breaker-resilience-architecture/workflow.fz @@ -0,0 +1,52 @@ +Client { # Client Service +n1: circle label:"Service Call" +n2: rectangle label:"Circuit Breaker Proxy" +n21: rectangle label:"Receive Response" +n22: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Breaker.n3.handle(top) [label="Check State"] +n21.handle(right) -> n22.handle(left) +} +Breaker { # Circuit Breaker +n3: diamond label:"Circuit State?" +n4: rectangle label:"Forward Request (Closed)" +n5: rectangle label:"Return Fallback (Open)" +n6: rectangle label:"Test Request (Half-Open)" +n13: rectangle label:"Track Success" +n14: rectangle label:"Track Failure" +n15: diamond label:"Failure Threshold?" +n16: rectangle label:"Trip Circuit Open" +n17: rectangle label:"Reset to Closed" +n18: rectangle label:"Start Recovery Timer" +n19: rectangle label:"Forward Success Response" +n20: rectangle label:"Forward Error Response" +n3.handle(right) -> n4.handle(left) [label="Closed"] +n3.handle(bottom) -> n5.handle(top) [label="Open"] +n3.handle(left) -> n6.handle(right) [label="Half-Open"] +n4.handle(bottom) -> Downstream.n7.handle(top) [label="Forward"] +n5.handle(top) -> Client.n21.handle(bottom) [label="Cached/Default"] +n6.handle(bottom) -> Downstream.n7.handle(top) [label="Probe"] +n13.handle(right) -> n17.handle(left) [label="Healthy"] +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Exceeded"] +n16.handle(right) -> n18.handle(left) [label="Cooldown"] +n17.handle(right) -> n19.handle(left) +n19.handle(top) -> Client.n21.handle(bottom) [label="Success"] +n18.handle(right) -> n20.handle(left) +n20.handle(top) -> Client.n21.handle(bottom) [label="Error"] +} +Downstream { # Downstream Service +n7: rectangle label:"Process Request" +n8: diamond label:"Response OK?" +n9: rectangle label:"Return Success" +n10: rectangle label:"Return Error/Timeout" +n11: rectangle label:"Send Success Signal" +n12: rectangle label:"Send Failure Signal" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="200"] +n8.handle(bottom) -> n10.handle(top) [label="5xx/Timeout"] +n9.handle(right) -> n11.handle(left) +n10.handle(right) -> n12.handle(left) +n11.handle(top) -> Breaker.n13.handle(bottom) [label="Success"] +n12.handle(top) -> Breaker.n14.handle(bottom) [label="Failure"] +} diff --git a/mcp/architecture/graphql-federation-architecture/README.md b/mcp/architecture/graphql-federation-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6de8b2fa297a0bd422f1c6c5d40999f99f8df5e2 --- /dev/null +++ b/mcp/architecture/graphql-federation-architecture/README.md @@ -0,0 +1,19 @@ +# GraphQL Federation Architecture + +A GraphQL federation architecture diagram with an Apollo Gateway building query plans and fanning out to User, Product, and Review subgraphs, each owning its schema and database, with response stitching into a unified GraphQL result. This template models the federated GraphQL approach where multiple teams independently develop and deploy their subgraphs while clients see a single unified API. Ideal for organizations scaling GraphQL across multiple teams and services. + +**Template ID:** `graphql-federation-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 15 +**Lanes:** 3 +**Tags:** [graphql-federation, apollo-gateway, subgraph, schema-stitching, query-plan, federated-api, graphql, architecture-diagram] +**Source path:** `` +**Repo path:** `mcp/architecture/graphql-federation-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/architecture/graphql-federation-architecture/metadata.json b/mcp/architecture/graphql-federation-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b7caa8f5556796bc9f712f7d24d07b38c3c09375 --- /dev/null +++ b/mcp/architecture/graphql-federation-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "graphql-federation-architecture", + "workflow_id": "graphql-federation-architecture", + "title": "GraphQL Federation Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 3, + "num_nodes": 15, + "num_lanes": 3, + "tags": [ + "graphql-federation", + "apollo-gateway", + "subgraph", + "schema-stitching", + "query-plan", + "federated-api", + "graphql", + "architecture-diagram" + ], + "description": "A GraphQL federation architecture diagram with an Apollo Gateway building query plans and fanning out to User, Product, and Review subgraphs, each owning its schema and database, with response stitching into a unified GraphQL result. This template models the federated GraphQL approach where multiple teams independently develop and deploy their subgraphs while clients see a single unified API. Ideal for organizations scaling GraphQL across multiple teams and services.", + "source_path": "", + "repo_path": "mcp/architecture/graphql-federation-architecture" +} diff --git a/mcp/architecture/graphql-federation-architecture/workflow.fz b/mcp/architecture/graphql-federation-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..170679688e4e42dd7840e2caea71ba00f51647dd --- /dev/null +++ b/mcp/architecture/graphql-federation-architecture/workflow.fz @@ -0,0 +1,51 @@ +Client { # Client Application +n1: circle label:"GraphQL Query" +n2: rectangle label:"Send to Gateway" +n21: rectangle label:"Receive Unified Response" +n22: circle label:"Render UI" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Gateway.n3.handle(top) [label="POST /graphql"] +n21.handle(right) -> n22.handle(left) +} +Gateway { # Apollo Federation Gateway +n3: rectangle label:"Parse GraphQL Query" +n4: rectangle label:"Build Query Plan" +n5: rectangle label:"Fan-Out to Subgraphs" +n18: rectangle label:"Merge Responses" +n19: rectangle label:"Return Unified Result" +n20: rectangle label:"Send to Client" +n3.handle(right) -> n4.handle(left) [label="AST"] +n4.handle(right) -> n5.handle(left) [label="Execution Plan"] +n5.handle(bottom) -> Subgraphs.n6.handle(top) [label="User Fields"] +n5.handle(bottom) -> Subgraphs.n8.handle(top) [label="Product Fields"] +n5.handle(bottom) -> Subgraphs.n10.handle(top) [label="Review Fields"] +n18.handle(right) -> n19.handle(left) [label="Stitched"] +n19.handle(right) -> n20.handle(left) +n20.handle(top) -> Client.n21.handle(bottom) [label="JSON"] +} +Subgraphs { # Federated Subgraphs +n6: rectangle label:"User Subgraph" +n7: rectangle label:"User Database" +n8: rectangle label:"Product Subgraph" +n9: rectangle label:"Product Database" +n10: rectangle label:"Review Subgraph" +n11: rectangle label:"Review Database" +n12: rectangle label:"Collect User Data" +n13: rectangle label:"Collect Product Data" +n14: rectangle label:"Collect Review Data" +n15: rectangle label:"Aggregate All Results" +n16: rectangle label:"Prepare Response" +n17: rectangle label:"Send Combined Data" +n6.handle(right) -> n7.handle(left) [label="Query"] +n8.handle(right) -> n9.handle(left) [label="Query"] +n10.handle(right) -> n11.handle(left) [label="Query"] +n7.handle(right) -> n12.handle(left) +n9.handle(right) -> n13.handle(left) +n11.handle(right) -> n14.handle(left) +n12.handle(bottom) -> n15.handle(top) [label="User Data"] +n13.handle(bottom) -> n15.handle(top) [label="Product Data"] +n14.handle(right) -> n15.handle(left) [label="Review Data"] +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> Gateway.n18.handle(bottom) [label="All Data"] +} diff --git a/mcp/architecture/microservices-service-mesh-architecture/README.md b/mcp/architecture/microservices-service-mesh-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1acbb8c6574a82fcbd42795da98ec8dafd9ea780 --- /dev/null +++ b/mcp/architecture/microservices-service-mesh-architecture/README.md @@ -0,0 +1,19 @@ +# Microservices Service Mesh Architecture + +A service mesh architecture diagram with Istio or Linkerd sidecar proxies handling mTLS encryption, traffic policies, circuit breaking, and distributed tracing across microservices. This template visualizes how a service mesh abstracts networking concerns away from application code, enabling zero-trust communication between services. Essential for teams adopting service mesh infrastructure to improve observability and security. + +**Template ID:** `microservices-service-mesh-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 3 +**Tags:** [service-mesh, istio, linkerd, mtls, sidecar-proxy, distributed-tracing, traffic-management, architecture-diagram] +**Source path:** `` +**Repo path:** `mcp/architecture/microservices-service-mesh-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/architecture/microservices-service-mesh-architecture/metadata.json b/mcp/architecture/microservices-service-mesh-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c01cf00de33a3b4aaba9f8c2f0f71732273bcbf6 --- /dev/null +++ b/mcp/architecture/microservices-service-mesh-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "microservices-service-mesh-architecture", + "workflow_id": "microservices-service-mesh-architecture", + "title": "Microservices Service Mesh Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 3, + "tags": [ + "service-mesh", + "istio", + "linkerd", + "mtls", + "sidecar-proxy", + "distributed-tracing", + "traffic-management", + "architecture-diagram" + ], + "description": "A service mesh architecture diagram with Istio or Linkerd sidecar proxies handling mTLS encryption, traffic policies, circuit breaking, and distributed tracing across microservices. This template visualizes how a service mesh abstracts networking concerns away from application code, enabling zero-trust communication between services. Essential for teams adopting service mesh infrastructure to improve observability and security.", + "source_path": "", + "repo_path": "mcp/architecture/microservices-service-mesh-architecture" +} diff --git a/mcp/architecture/microservices-service-mesh-architecture/workflow.fz b/mcp/architecture/microservices-service-mesh-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..2931fe2e4c7c543a41b98438fe3f1d5af5caab59 --- /dev/null +++ b/mcp/architecture/microservices-service-mesh-architecture/workflow.fz @@ -0,0 +1,52 @@ +Ingress { # Ingress Controller +n1: circle label:"External Traffic" +n2: rectangle label:"TLS Termination" +n3: rectangle label:"Route to Service Mesh" +n22: rectangle label:"Receive Mesh Response" +n23: circle label:"Response to Client" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Mesh.n4.handle(top) [label="Enter Mesh"] +n22.handle(right) -> n23.handle(left) +} +Mesh { # Service Mesh (Istio/Linkerd) +n4: rectangle label:"Sidecar Proxy Intercept" +n5: rectangle label:"mTLS Encryption" +n6: rectangle label:"Traffic Policy Check" +n7: diamond label:"Circuit Breaker Open?" +n8: rectangle label:"Load Balance Request" +n9: rectangle label:"Return Fallback" +n18: rectangle label:"Receive Service Response" +n19: rectangle label:"Collect Telemetry" +n20: rectangle label:"Distributed Tracing" +n21: rectangle label:"Forward to Ingress" +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Closed"] +n7.handle(bottom) -> n9.handle(top) [label="Open"] +n8.handle(bottom) -> Services.n10.handle(top) [label="Forward"] +n9.handle(bottom) -> Services.n16.handle(top) [label="Fallback"] +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(top) -> Ingress.n22.handle(bottom) [label="Mesh Response"] +} +Services { # Backend Services +n10: rectangle label:"Product Catalog Service" +n11: rectangle label:"Pricing Service" +n12: rectangle label:"Recommendation Engine" +n13: rectangle label:"Response Aggregation" +n14: rectangle label:"Sidecar Proxy Egress" +n15: rectangle label:"Return to Mesh" +n16: rectangle label:"Cached Fallback Response" +n17: rectangle label:"Return Fallback to Mesh" +n10.handle(right) -> n11.handle(left) [label="Get Prices"] +n11.handle(right) -> n12.handle(left) [label="Enrich"] +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(top) -> Mesh.n18.handle(bottom) [label="Service Response"] +n16.handle(right) -> n17.handle(left) [label="Stale Data"] +n17.handle(top) -> Mesh.n18.handle(bottom) [label="Fallback Response"] +} diff --git a/mcp/architecture/microservices-sidecar-pattern-architecture/README.md b/mcp/architecture/microservices-sidecar-pattern-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..52a6595e4ecbed9ecf2c19c0bf4dd8c868b566c8 --- /dev/null +++ b/mcp/architecture/microservices-sidecar-pattern-architecture/README.md @@ -0,0 +1,19 @@ +# Microservices Sidecar Pattern Architecture + +A sidecar pattern architecture diagram showing Envoy proxy, log collector, and config watcher sidecars running alongside application containers in a Kubernetes pod, with a control plane managing configuration. This template demonstrates how auxiliary concerns like logging, monitoring, and configuration are deployed as co-located containers. Foundational for teams adopting cloud-native container orchestration patterns. + +**Template ID:** `microservices-sidecar-pattern-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 3 +**Tags:** [sidecar-pattern, envoy-proxy, kubernetes, container-pattern, observability, control-plane, cloud-native, architecture-diagram] +**Source path:** `` +**Repo path:** `mcp/architecture/microservices-sidecar-pattern-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/architecture/microservices-sidecar-pattern-architecture/metadata.json b/mcp/architecture/microservices-sidecar-pattern-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4b8a0eba546a10af9a8a33513bdf926b17cd1dba --- /dev/null +++ b/mcp/architecture/microservices-sidecar-pattern-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "microservices-sidecar-pattern-architecture", + "workflow_id": "microservices-sidecar-pattern-architecture", + "title": "Microservices Sidecar Pattern Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 3, + "tags": [ + "sidecar-pattern", + "envoy-proxy", + "kubernetes", + "container-pattern", + "observability", + "control-plane", + "cloud-native", + "architecture-diagram" + ], + "description": "A sidecar pattern architecture diagram showing Envoy proxy, log collector, and config watcher sidecars running alongside application containers in a Kubernetes pod, with a control plane managing configuration. This template demonstrates how auxiliary concerns like logging, monitoring, and configuration are deployed as co-located containers. Foundational for teams adopting cloud-native container orchestration patterns.", + "source_path": "", + "repo_path": "mcp/architecture/microservices-sidecar-pattern-architecture" +} diff --git a/mcp/architecture/microservices-sidecar-pattern-architecture/workflow.fz b/mcp/architecture/microservices-sidecar-pattern-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..320fd8d28d5bc378f1b3dc32434ae83f8c8401b6 --- /dev/null +++ b/mcp/architecture/microservices-sidecar-pattern-architecture/workflow.fz @@ -0,0 +1,37 @@ +ControlPlane { # Control Plane +n1: rectangle label:"Service Mesh Control Plane" +n2: rectangle label:"Push Configuration" +n3: rectangle label:"Certificate Authority" +n15: rectangle label:"Receive Config Ack" +n16: rectangle label:"Config Confirmed" +n1.handle(right) -> n2.handle(left) [label="Policy"] +n2.handle(bottom) -> Pod.n4.handle(top) [label="xDS Config"] +n3.handle(bottom) -> Pod.n4.handle(top) [label="mTLS Cert"] +n15.handle(right) -> n16.handle(left) +} +Pod { # Kubernetes Pod +n4: rectangle label:"Envoy Sidecar Proxy" +n5: rectangle label:"Config Watcher Sidecar" +n6: rectangle label:"Application Container" +n7: rectangle label:"Log Collector Sidecar" +n8: rectangle label:"Send Log Batch" +n13: rectangle label:"Receive Log Ack" +n14: rectangle label:"Acknowledge Config" +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) [label="Config Applied"] +n6.handle(right) -> n7.handle(left) [label="Logs"] +n7.handle(right) -> n8.handle(left) +n8.handle(bottom) -> Observability.n9.handle(top) [label="Ship Logs"] +n13.handle(right) -> n14.handle(left) +n14.handle(top) -> ControlPlane.n15.handle(bottom) [label="Config Ack"] +} +Observability { # Observability Stack +n9: rectangle label:"ELK Log Aggregation" +n10: rectangle label:"Prometheus Metrics" +n11: rectangle label:"Jaeger Tracing" +n12: rectangle label:"Return Log Ack" +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Traces"] +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> Pod.n13.handle(bottom) [label="Logs Received"] +} diff --git a/mcp/architecture/serverless-api-backend-architecture/README.md b/mcp/architecture/serverless-api-backend-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..aef554506d6af653525c54b26bf40ae86c73d6bc --- /dev/null +++ b/mcp/architecture/serverless-api-backend-architecture/README.md @@ -0,0 +1,19 @@ +# Serverless API Backend Architecture + +A serverless API backend architecture diagram with API Gateway, Lambda authorizer functions, business logic functions, and managed cloud services including DynamoDB, S3, SQS, and SNS for a fully managed, auto-scaling backend. This template models the serverless-first approach where infrastructure management is eliminated entirely, with pay-per-invocation pricing and automatic scaling to zero. Essential for startups and teams building cost-efficient, event-driven API backends. + +**Template ID:** `serverless-api-backend-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 15 +**Lanes:** 3 +**Tags:** [serverless, aws-lambda, api-gateway, dynamodb, cloud-architecture, auto-scaling, pay-per-use, architecture-diagram] +**Source path:** `` +**Repo path:** `mcp/architecture/serverless-api-backend-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/architecture/serverless-api-backend-architecture/metadata.json b/mcp/architecture/serverless-api-backend-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..580f9be2ac77ce77918048d119566ecf121a784f --- /dev/null +++ b/mcp/architecture/serverless-api-backend-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "serverless-api-backend-architecture", + "workflow_id": "serverless-api-backend-architecture", + "title": "Serverless API Backend Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 3, + "num_nodes": 15, + "num_lanes": 3, + "tags": [ + "serverless", + "aws-lambda", + "api-gateway", + "dynamodb", + "cloud-architecture", + "auto-scaling", + "pay-per-use", + "architecture-diagram" + ], + "description": "A serverless API backend architecture diagram with API Gateway, Lambda authorizer functions, business logic functions, and managed cloud services including DynamoDB, S3, SQS, and SNS for a fully managed, auto-scaling backend. This template models the serverless-first approach where infrastructure management is eliminated entirely, with pay-per-invocation pricing and automatic scaling to zero. Essential for startups and teams building cost-efficient, event-driven API backends.", + "source_path": "", + "repo_path": "mcp/architecture/serverless-api-backend-architecture" +} diff --git a/mcp/architecture/serverless-api-backend-architecture/workflow.fz b/mcp/architecture/serverless-api-backend-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6730eb6984b7b9e03ae55d84e4bc11544318bae7 --- /dev/null +++ b/mcp/architecture/serverless-api-backend-architecture/workflow.fz @@ -0,0 +1,39 @@ +Client { # Client Application +n1: circle label:"API Request" +n2: rectangle label:"API Gateway (AWS/Azure)" +n16: rectangle label:"Receive Response" +n17: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Functions.n3.handle(top) [label="Invoke Lambda"] +n16.handle(right) -> n17.handle(left) +} +Functions { # Serverless Functions +n3: rectangle label:"Auth Authorizer Lambda" +n4: diamond label:"Token Valid?" +n5: rectangle label:"Business Logic Lambda" +n6: rectangle label:"Return 401" +n13: rectangle label:"Receive Data" +n14: rectangle label:"Data Validation Lambda" +n15: rectangle label:"Response Formatter" +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="Authorized"] +n4.handle(bottom) -> n6.handle(top) [label="Denied"] +n5.handle(bottom) -> ManagedServices.n7.handle(top) [label="Read/Write"] +n6.handle(top) -> Client.n16.handle(bottom) [label="401"] +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Validated"] +n15.handle(top) -> Client.n16.handle(bottom) [label="200 JSON"] +} +ManagedServices { # Managed Cloud Services +n7: rectangle label:"DynamoDB / CosmosDB" +n8: rectangle label:"S3 Object Storage" +n9: rectangle label:"SQS Message Queue" +n10: rectangle label:"SNS Notification" +n11: rectangle label:"CloudWatch Logs" +n12: rectangle label:"Return Data" +n7.handle(right) -> n8.handle(left) [label="Store Assets"] +n9.handle(right) -> n10.handle(left) [label="Trigger"] +n10.handle(right) -> n11.handle(left) [label="Log"] +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> Functions.n13.handle(bottom) [label="Data Response"] +} diff --git a/mcp/devops/mcp-circuit-breaker/README.md b/mcp/devops/mcp-circuit-breaker/README.md new file mode 100644 index 0000000000000000000000000000000000000000..128d7367b398bed16b8d4738a442da4538c6189c --- /dev/null +++ b/mcp/devops/mcp-circuit-breaker/README.md @@ -0,0 +1,19 @@ +# MCP Circuit Breaker Architecture + +A resilience pattern that wraps MCP calls with health-aware gates using three states: Closed (normal), Open (failures detected, fast-fail), and Half-Open (testing recovery). Prevents cascading failures when tools become unresponsive. Essential for production-grade reliability. + +**Template ID:** `mcp-circuit-breaker` +**Kind:** architecture +**Source domain:** DevOps +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 9 +**Lanes:** 3 +**Tags:** [mcp, circuit-breaker, resilience, fault-tolerance, health-check, architecture-diagram, production-grade] +**Source path:** `` +**Repo path:** `mcp/devops/mcp-circuit-breaker` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/devops/mcp-circuit-breaker/metadata.json b/mcp/devops/mcp-circuit-breaker/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b6935b8c9e2e379193979f17866732c74a08c223 --- /dev/null +++ b/mcp/devops/mcp-circuit-breaker/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "mcp-circuit-breaker", + "workflow_id": "mcp-circuit-breaker", + "title": "MCP Circuit Breaker Architecture", + "kind": "architecture", + "source_domain": "DevOps", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 3, + "num_nodes": 9, + "num_lanes": 3, + "tags": [ + "mcp", + "circuit-breaker", + "resilience", + "fault-tolerance", + "health-check", + "architecture-diagram", + "production-grade" + ], + "description": "A resilience pattern that wraps MCP calls with health-aware gates using three states: Closed (normal), Open (failures detected, fast-fail), and Half-Open (testing recovery). Prevents cascading failures when tools become unresponsive. Essential for production-grade reliability.", + "source_path": "", + "repo_path": "mcp/devops/mcp-circuit-breaker" +} diff --git a/mcp/devops/mcp-circuit-breaker/workflow.fz b/mcp/devops/mcp-circuit-breaker/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e88a866acdfca618eb99fa22c76bb3c890b519bd --- /dev/null +++ b/mcp/devops/mcp-circuit-breaker/workflow.fz @@ -0,0 +1,37 @@ +Host { # Host Application + n1: circle label="User sends prompt" + n2: rectangle label="Agent prepares MCP call" + n3: rectangle label="Pass call to circuit breaker" + n4: rectangle label="Receive result or error" + n5: rectangle label="Agent responds to user" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> CB.n6.handle(top) [label="MCP tool call"] + n4.handle(right) -> n5.handle(left) +} + +CB { # Circuit Breaker + n6: rectangle label="Check circuit state" + n7: diamond label="Circuit open?" + n8: rectangle label="Forward to MCP server" + n9: rectangle label="Fast-fail with error" + n10: diamond label="Call succeeded?" + n11: rectangle label="Record success" + n12: rectangle label="Record failure and check threshold" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) [label="Closed"] + n7.handle(bottom) -> n9.handle(top) [label="Open"] + n8.handle(bottom) -> MCPServer.n13.handle(top) [label="Forward request"] + n9.handle(top) -> Host.n4.handle(bottom) [label="CircuitOpenError"] + n10.handle(right) -> n11.handle(left) [label="Yes"] + n10.handle(bottom) -> n12.handle(top) [label="No"] + n11.handle(top) -> Host.n4.handle(left) [label="Return result"] + n12.handle(top) -> Host.n4.handle(right) [label="Return error"] +} + +MCPServer { # MCP Server + n13: rectangle label="Attempt tool execution" + n14: rectangle label="Return result or error" + n13.handle(right) -> n14.handle(left) + n14.handle(top) -> CB.n10.handle(bottom) [label="Execution outcome"] +} diff --git a/mcp/devops/mcp-context-proxy/README.md b/mcp/devops/mcp-context-proxy/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ba565513b81364ae7b2ba5157144e0718e284ead --- /dev/null +++ b/mcp/devops/mcp-context-proxy/README.md @@ -0,0 +1,19 @@ +# MCP Context Proxy Architecture + +A caching and compression layer that sits between agents and MCP servers, intercepting redundant context requests before they hit the wire. Uses TTL-based cache invalidation, Brotli compression, and semantic caching. Can achieve up to 95%+ token reduction and significantly lower LLM bills. + +**Template ID:** `mcp-context-proxy` +**Kind:** architecture +**Source domain:** DevOps +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 3 +**Tags:** [mcp, context-proxy, caching, compression, token-optimization, architecture-diagram, production-grade] +**Source path:** `` +**Repo path:** `mcp/devops/mcp-context-proxy` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/devops/mcp-context-proxy/metadata.json b/mcp/devops/mcp-context-proxy/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..32cc6ca30fefc815c170a982dd3b671359d1b94e --- /dev/null +++ b/mcp/devops/mcp-context-proxy/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "mcp-context-proxy", + "workflow_id": "mcp-context-proxy", + "title": "MCP Context Proxy Architecture", + "kind": "architecture", + "source_domain": "DevOps", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 3, + "tags": [ + "mcp", + "context-proxy", + "caching", + "compression", + "token-optimization", + "architecture-diagram", + "production-grade" + ], + "description": "A caching and compression layer that sits between agents and MCP servers, intercepting redundant context requests before they hit the wire. Uses TTL-based cache invalidation, Brotli compression, and semantic caching. Can achieve up to 95%+ token reduction and significantly lower LLM bills.", + "source_path": "", + "repo_path": "mcp/devops/mcp-context-proxy" +} diff --git a/mcp/devops/mcp-context-proxy/workflow.fz b/mcp/devops/mcp-context-proxy/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0c1c794d8f7cbcb0574d3a863d9a0665c7d13100 --- /dev/null +++ b/mcp/devops/mcp-context-proxy/workflow.fz @@ -0,0 +1,32 @@ +Host { # Host Application + n1: circle label="User sends prompt" + n2: rectangle label="Agent requests context" + n3: rectangle label="Receive context" + n4: rectangle label="Agent responds to user" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Proxy.n5.handle(top) [label="Context request"] + n3.handle(right) -> n4.handle(left) +} + +Proxy { # Context Proxy + n5: rectangle label="Receive context request" + n6: rectangle label="Check cache with TTL" + n7: diamond label="Cache hit?" + n8: rectangle label="Return cached context" + n9: rectangle label="Fetch fresh from MCP server" + n10: rectangle label="Compress and cache response" + n5.handle(right) -> n6.handle(left) + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) [label="Hit"] + n7.handle(bottom) -> n9.handle(top) [label="Miss"] + n8.handle(top) -> Host.n3.handle(bottom) [label="Cached context"] + n9.handle(bottom) -> MCPServer.n11.handle(top) [label="Fetch request"] + n10.handle(top) -> Host.n3.handle(left) [label="Fresh context"] +} + +MCPServer { # MCP Server + n11: rectangle label="Fetch full context" + n12: rectangle label="Return fresh data" + n11.handle(right) -> n12.handle(left) + n12.handle(top) -> Proxy.n10.handle(bottom) [label="Fresh data"] +} diff --git a/mcp/devops/mcp-direct-connect/README.md b/mcp/devops/mcp-direct-connect/README.md new file mode 100644 index 0000000000000000000000000000000000000000..057f322a086723ce929de5991ad2db309791d92d --- /dev/null +++ b/mcp/devops/mcp-direct-connect/README.md @@ -0,0 +1,19 @@ +# MCP Direct Connect Architecture + +The simplest MCP pattern — direct connection between host application and MCP server over stdio or HTTP. No extra hops, lowest latency, easiest debugging. Perfect for MVPs, hackathons, and single-team setups where security governance is not yet a concern. + +**Template ID:** `mcp-direct-connect` +**Kind:** architecture +**Source domain:** DevOps +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 1/5 +**Nodes:** 6 +**Lanes:** 2 +**Tags:** [mcp, direct-connect, stdio, http, architecture-diagram, production-grade] +**Source path:** `` +**Repo path:** `mcp/devops/mcp-direct-connect` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/devops/mcp-direct-connect/metadata.json b/mcp/devops/mcp-direct-connect/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d5168d37cb37f0b4d7ee4d4b17e32fd3dcebbc6f --- /dev/null +++ b/mcp/devops/mcp-direct-connect/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "mcp-direct-connect", + "workflow_id": "mcp-direct-connect", + "title": "MCP Direct Connect Architecture", + "kind": "architecture", + "source_domain": "DevOps", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 1, + "num_nodes": 6, + "num_lanes": 2, + "tags": [ + "mcp", + "direct-connect", + "stdio", + "http", + "architecture-diagram", + "production-grade" + ], + "description": "The simplest MCP pattern — direct connection between host application and MCP server over stdio or HTTP. No extra hops, lowest latency, easiest debugging. Perfect for MVPs, hackathons, and single-team setups where security governance is not yet a concern.", + "source_path": "", + "repo_path": "mcp/devops/mcp-direct-connect" +} diff --git a/mcp/devops/mcp-direct-connect/workflow.fz b/mcp/devops/mcp-direct-connect/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d15e9edd65a81146fcfc56ca58e4aaaa99c2100f --- /dev/null +++ b/mcp/devops/mcp-direct-connect/workflow.fz @@ -0,0 +1,20 @@ +Host { # Host Application + n1: circle label="User sends prompt" + n2: rectangle label="Agent builds JSON-RPC request" + n3: rectangle label="Send request via stdio" + n4: rectangle label="Receive JSON-RPC result" + n5: rectangle label="Agent responds to user" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> MCPServer.n6.handle(top) [label="JSON-RPC request"] + n4.handle(right) -> n5.handle(left) +} + +MCPServer { # MCP Server + n6: rectangle label="Parse incoming request" + n7: rectangle label="Execute tool or resource" + n8: rectangle label="Build JSON-RPC response" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n8.handle(top) -> Host.n4.handle(bottom) [label="JSON-RPC response"] +} diff --git a/mcp/patterns/circuit-breaker-workflow/README.md b/mcp/patterns/circuit-breaker-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ba37bade3157c5cfb8f2f044cfc22b5c459fe1c4 --- /dev/null +++ b/mcp/patterns/circuit-breaker-workflow/README.md @@ -0,0 +1,19 @@ +# Circuit Breaker Workflow + +Circuit breaker resilience pattern with closed, open, and half-open states for protecting services from cascading failures with automatic recovery testing. + +**Template ID:** `circuit-breaker-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** mcp +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 3 +**Tags:** [circuit-breaker, resilience, fault-tolerance, microservices, hystrix, half-open, fallback] +**Source path:** `patterns/circuit-breaker` +**Repo path:** `mcp/patterns/circuit-breaker-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/mcp/patterns/circuit-breaker-workflow/metadata.json b/mcp/patterns/circuit-breaker-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3a7da86c70fefba166315c1783c90f72faee0c02 --- /dev/null +++ b/mcp/patterns/circuit-breaker-workflow/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "circuit-breaker-workflow", + "workflow_id": "circuit-breaker", + "title": "Circuit Breaker Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "mcp", + "secondary_use_cases": [], + "use_cases": [ + "mcp" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 3, + "tags": [ + "circuit-breaker", + "resilience", + "fault-tolerance", + "microservices", + "hystrix", + "half-open", + "fallback" + ], + "description": "Circuit breaker resilience pattern with closed, open, and half-open states for protecting services from cascading failures with automatic recovery testing.", + "source_path": "patterns/circuit-breaker", + "repo_path": "mcp/patterns/circuit-breaker-workflow" +} diff --git a/mcp/patterns/circuit-breaker-workflow/workflow.fz b/mcp/patterns/circuit-breaker-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e347a51239333b7ae013b9ac2c0b10b597271f1e --- /dev/null +++ b/mcp/patterns/circuit-breaker-workflow/workflow.fz @@ -0,0 +1,43 @@ +Client { # Client Application +n1: circle label:"Start" +n2: rectangle label:"Initiate service call" +n3: rectangle label:"Receive response" +n4: rectangle label:"Process fallback response" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> CircuitBreaker.n6.handle(top) [label="Request"] +n3.handle(right) -> n5.handle(left) +n4.handle(right) -> n5.handle(left) +} +CircuitBreaker { # Circuit Breaker +n6: diamond label:"Circuit state?" +n7: rectangle label:"Allow request through" +n8: rectangle label:"Return cached fallback" +n9: rectangle label:"Increment failure count" +n10: diamond label:"Failure threshold reached?" +n11: rectangle label:"Open circuit" +n12: rectangle label:"Reset failure count" +n13: rectangle label:"Start half-open timer" +n6.handle(right) -> n7.handle(left) [label="Closed"] +n6.handle(bottom) -> n8.handle(top) [label="Open"] +n6.handle(left) -> n7.handle(top) [label="Half-Open"] +n7.handle(bottom) -> ExternalService.n14.handle(top) [label="Forward"] +n8.handle(top) -> Client.n4.handle(bottom) [label="Fallback"] +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n12.handle(top) [label="No"] +n11.handle(right) -> n13.handle(left) +n12.handle(top) -> Client.n3.handle(bottom) [label="Success"] +n13.handle(top) -> Client.n4.handle(bottom) [label="Tripped"] +} +ExternalService { # External Service +n14: rectangle label:"Process request" +n15: diamond label:"Request successful?" +n16: rectangle label:"Return success response" +n17: rectangle label:"Return error response" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(top) -> CircuitBreaker.n12.handle(bottom) [label="OK"] +n17.handle(top) -> CircuitBreaker.n9.handle(bottom) [label="Error"] +} diff --git a/metadata.csv b/metadata.csv new file mode 100644 index 0000000000000000000000000000000000000000..e24c96575d0ec0c76a311582d969286dcae6baee --- /dev/null +++ b/metadata.csv @@ -0,0 +1,243 @@ +template_id,workflow_id,title,kind,source_domain,primary_use_case,secondary_use_cases,use_cases,complexity,num_nodes,num_lanes,tags,description,source_path,repo_path +a-b-testing-workflow,a-b-testing,A B Testing Workflow,workflow,patterns,uncategorized,,,3,10,3,a;b;testing;patterns,This workflow models comparing two versions to see which performs better.,patterns/a-b-testing,uncategorized/patterns/a-b-testing-workflow +ab-test-setup-workflow,ab-test-setup,Ab Test Setup Workflow,workflow,business-operations,onboarding,,onboarding,3,10,3,ab-testing;experimentation;split-testing;statistical-significance;conversion-optimization;optimizely,"A/B test setup workflow with hypothesis definition, variant creation, traffic allocation, statistical analysis, and winner deployment.",business-operations/ab-test-setup,onboarding/business-operations/ab-test-setup-workflow +access-review-workflow,access-review,Access Review Workflow,workflow,devops,approval,compliance,approval;compliance,4,18,3,access-review;user-access-certification;quarterly-review;manager-approval;compliance;sod-violations;audit,"Quarterly user access review workflow with manager certification, separation of duties validation, remediation tracking, and compliance reporting for audit purposes.",devops/access-review,approval/devops/access-review-workflow +account-deletion-workflow,account-deletion,Account Deletion Workflow,workflow,business-operations,offboarding,billing,offboarding;billing,3,7,2,account-deletion;user-offboarding;data-cleanup;subscription-cancel;retention-offer;exit-survey,"Account deletion workflow with cancellation reason capture, retention offer, subscription termination, data cleanup, and confirmation email.",business-operations/account-deletion,offboarding/business-operations/account-deletion-workflow +api-gateway-workflow,api-gateway,Api Gateway Workflow,workflow,patterns,handoff,security;mcp,handoff;security;mcp,3,7,2,api-gateway;microservices;rate-limiting;request-routing;authentication;load-balancing,"API Gateway pattern with request authentication, rate limiting, request routing to backend services, response aggregation, and error handling.",patterns/api-gateway,handoff/patterns/api-gateway-workflow +api-key-rotation-workflow,api-key-rotation,Api Key Rotation Workflow,workflow,business-operations,security,compliance,security;compliance,3,10,3,api-key-rotation;security;credential-management;zero-downtime;secrets-manager;compliance,"API key rotation workflow with new key generation, dual-key transition period, client notification, old key deprecation, and audit logging.",business-operations/api-key-rotation,security/business-operations/api-key-rotation-workflow +audit-trail-workflow,audit-trail,Audit Trail Workflow,workflow,patterns,compliance,,compliance,4,13,4,audit;trail;patterns;decision;loop,This workflow models logging all important actions for compliance.,patterns/audit-trail,compliance/patterns/audit-trail-workflow +authentication-flow-workflow,authentication-flow,Authentication Flow Workflow,workflow,patterns,security,,security,3,7,2,authentication;login;jwt;oauth;mfa;session-management,"User authentication workflow with credential validation, MFA challenge, JWT token generation, session creation, and failed attempt tracking.",patterns/authentication-flow,security/patterns/authentication-flow-workflow +authorization-flow-workflow,authorization-flow,Authorization Flow Workflow,workflow,patterns,approval,security,approval;security,3,10,3,authorization;flow;patterns,This workflow models checking user permissions before actions run.,patterns/authorization-flow,approval/patterns/authorization-flow-workflow +background-check-workflow,background-check,Background Check Workflow,workflow,hr,uncategorized,,,3,7,2,background-check;pre-employment;criminal-history;employment-verification;education-verification;drug-screening,"Pre-employment background check workflow with criminal history search, employment verification, education verification, and drug screening coordination.",hr/background-check,uncategorized/hr/background-check-workflow +backup-restore-workflow,backup-restore,Backup Restore Workflow,workflow,devops,delivery,,delivery,3,10,3,backup-restore;disaster-recovery;rpo-rto;snapshot;data-protection;recovery-testing,"Backup and restore workflow with scheduled backups, offsite replication, retention policy enforcement, restore testing, and RTO/RPO validation.",devops/backup-restore,delivery/devops/backup-restore-workflow +bank-reconciliation-workflow,bank-reconciliation,Bank Reconciliation Workflow,workflow,finance,uncategorized,,,4,18,3,bank-reconciliation;gl-matching;variance-analysis;journal-entries;auto-matching;discrepancy-resolution,"Bank reconciliation workflow with automated transaction matching, variance reporting, discrepancy research, and journal entry creation for timing differences and bank errors.",finance/bank-reconciliation,uncategorized/finance/bank-reconciliation-workflow +batch-processing-workflow,batch-processing,Batch Processing Workflow,workflow,patterns,uncategorized,,,3,7,2,batch-processing;scheduled-jobs;bulk-operations;etl;chunk-processing;job-scheduler,"Batch processing pattern with job scheduling, chunk-based processing, checkpoint/restart capability, error handling, and completion reporting.",patterns/batch-processing,uncategorized/patterns/batch-processing-workflow +billing-dispute-workflow,billing-dispute,Billing Dispute Workflow,workflow,business-operations,approval,billing,approval;billing,4,13,4,billing-dispute;chargeback;refund-request;dispute-resolution;fraud-review;stripe,"Billing dispute workflow with dispute intake, transaction review, fraud analysis, resolution decision, and chargeback response handling.",business-operations/billing-dispute,approval/business-operations/billing-dispute-workflow +blue-green-deploy-workflow,blue-green-deploy,Blue Green Deploy Workflow,workflow,patterns,delivery,,delivery,4,13,4,blue-green-deployment;zero-downtime;traffic-switching;rollback;load-balancer;release-management,"Blue-green deployment pattern with parallel environment setup, smoke testing, load balancer traffic switch, and instant rollback capability.",patterns/blue-green-deploy,delivery/patterns/blue-green-deploy-workflow +bonus-allocation-workflow,bonus-allocation,Bonus Allocation Workflow,workflow,hr,uncategorized,,,3,7,2,bonus-allocation;annual-bonus;performance-bonus;budget-pool;calibration;payout,"Annual bonus allocation workflow with budget pool distribution, performance-based calculation, manager calibration, executive approval, and payroll processing.",hr/bonus-allocation,uncategorized/hr/bonus-allocation-workflow +budget-approval-workflow,budget-approval,Budget Approval Workflow,workflow,finance,approval,,approval,4,19,3,budget-approval;financial-planning;tiered-approval;cfo-approval;ceo-approval;board-approval;fund-allocation,"Corporate budget approval workflow with tiered approval routing based on amount thresholds (CFO < $100K, CEO $100K-$1M, Board > $1M), prior year comparison, and fund allocation.",finance/budget-approval,approval/finance/budget-approval-workflow +cache-aside-workflow,cache-aside,Cache Aside Workflow,workflow,patterns,uncategorized,,,3,10,3,cache-aside;lazy-loading;cache-miss;cache-invalidation;redis;performance,"Cache-aside pattern with cache lookup, database fallback on miss, cache population, TTL-based expiration, and write-through invalidation.",patterns/cache-aside,uncategorized/patterns/cache-aside-workflow +callback-pattern-workflow,callback-pattern,Callback Pattern Workflow,workflow,patterns,uncategorized,,,3,10,3,callback;pattern;patterns;decision;loop,This workflow models an async operation that notifies a callback when done.,patterns/callback-pattern,uncategorized/patterns/callback-pattern-workflow +canary-deploy-workflow,canary-deploy,Canary Deploy Workflow,workflow,patterns,incident,delivery,incident;delivery,3,7,2,canary-deployment;progressive-rollout;traffic-splitting;metrics-monitoring;gradual-release;feature-flags,"Canary deployment pattern with gradual traffic shifting, real-time metrics monitoring, automatic rollback triggers, and progressive rollout to full production.",patterns/canary-deploy,incident/patterns/canary-deploy-workflow +candidate-rejection-workflow,candidate-rejection,Candidate Rejection Workflow,workflow,hr,uncategorized,,,3,10,3,candidate-rejection;hiring-decision;rejection-letter;talent-pool;candidate-experience;ats-update,"Candidate rejection workflow with stage-appropriate messaging, personalized rejection letters, talent pool consideration, ATS status update, and candidate experience feedback.",hr/candidate-rejection,uncategorized/hr/candidate-rejection-workflow +carrier-selection-workflow,carrier-selection,Carrier Selection Workflow,workflow,logistics,uncategorized,,,3,10,3,carrier-selection;rate-shopping;transit-time;service-level;tms;freight-optimization,"Carrier selection workflow with rate shopping, transit time comparison, service level matching, carrier performance scoring, and optimal carrier assignment.",logistics/carrier-selection,uncategorized/logistics/carrier-selection-workflow +cash-flow-forecast-workflow,cash-flow-forecast,Cash Flow Forecast Workflow,workflow,finance,uncategorized,,,3,7,2,cash-flow-forecast;liquidity-planning;working-capital;ar-collections;ap-disbursements;treasury,"Cash flow forecasting workflow with AR/AP projections, working capital analysis, liquidity gap identification, and short-term financing recommendations.",finance/cash-flow-forecast,uncategorized/finance/cash-flow-forecast-workflow +certificate-renewal-workflow,certificate-renewal,Certificate Renewal Workflow,workflow,devops,security,,security,4,19,3,ssl-certificate;tls-renewal;lets-encrypt;certificate-authority;domain-validation;load-balancer;health-check,"SSL/TLS certificate renewal workflow with expiration monitoring, certificate request by type (DV/OV/EV), domain validation, deployment to load balancers, and health check verification with rollback.",devops/certificate-renewal,security/devops/certificate-renewal-workflow +chaos-engineering-workflow,chaos-engineering,Chaos Engineering Workflow,workflow,devops,uncategorized,,,4,13,4,chaos-engineering;fault-injection;resilience-testing;game-day;blast-radius;steady-state,"Chaos engineering workflow with hypothesis definition, steady-state monitoring, controlled fault injection, blast radius limitation, and resilience validation.",devops/chaos-engineering,uncategorized/devops/chaos-engineering-workflow +ci-cd-pipeline-workflow,ci-cd-pipeline,Ci Cd Pipeline Workflow,workflow,devops,delivery,,delivery,4,22,3,ci-cd;continuous-integration;continuous-deployment;github-actions;artifact-registry;staging;production;rollback,"Full CI/CD pipeline with code checkout, linting, unit tests, artifact building, staging deployment, smoke tests, production deployment, and automatic rollback on failure.",devops/ci-cd-pipeline,delivery/devops/ci-cd-pipeline-workflow +circuit-breaker-workflow,circuit-breaker,Circuit Breaker Workflow,workflow,patterns,mcp,,mcp,4,19,3,circuit-breaker;resilience;fault-tolerance;microservices;hystrix;half-open;fallback,"Circuit breaker resilience pattern with closed, open, and half-open states for protecting services from cascading failures with automatic recovery testing.",patterns/circuit-breaker,mcp/patterns/circuit-breaker-workflow +claim-check-workflow,claim-check,Claim Check Workflow,workflow,patterns,uncategorized,,,2,7,2,claim;check;patterns,This workflow models keeping large payloads external and only passing references.,patterns/claim-check,uncategorized/patterns/claim-check-workflow +cohort-analysis-workflow,cohort-analysis,Cohort Analysis Workflow,workflow,business-operations,uncategorized,,,4,13,4,cohort-analysis;retention-analysis;user-behavior;ltv;churn-prediction;analytics,"Cohort analysis workflow with user segmentation by signup date, retention curve calculation, LTV projection, and behavioral pattern identification.",business-operations/cohort-analysis,uncategorized/business-operations/cohort-analysis-workflow +cold-chain-monitoring-workflow,cold-chain-monitoring,Cold Chain Monitoring Workflow,workflow,logistics,incident,,incident,3,7,2,cold-chain;temperature-monitoring;iot-sensors;excursion-alert;pharmaceutical;perishables,"Cold chain monitoring workflow with IoT temperature sensors, real-time alerts, excursion documentation, corrective action triggers, and compliance reporting.",logistics/cold-chain-monitoring,incident/logistics/cold-chain-monitoring-workflow +community-moderation-workflow,community-moderation,Community Moderation Workflow,workflow,business-operations,uncategorized,,,3,7,2,community-moderation;content-moderation;user-reports;trust-safety;ai-moderation;appeals,"Community content moderation workflow with AI auto-flagging, user reports, human review queue, action enforcement, and appeals handling.",business-operations/community-moderation,uncategorized/business-operations/community-moderation-workflow +compensation-transaction-workflow,compensation-transaction,Compensation Transaction Workflow,workflow,patterns,uncategorized,,,2,7,2,compensation;transaction;patterns;decision;loop,This workflow models rolling back work when a later step fails.,patterns/compensation-transaction,uncategorized/patterns/compensation-transaction-workflow +conflict-resolution-workflow,conflict-resolution,Conflict Resolution Workflow,workflow,hr,billing,,billing,4,10,3,conflict-resolution;workplace-dispute;mediation;hr-investigation;employee-relations;grievance,"Workplace conflict resolution workflow with complaint intake, HR investigation, mediation sessions, resolution documentation, and follow-up monitoring.",hr/conflict-resolution,billing/hr/conflict-resolution-workflow +consent-management-workflow,consent-management,Consent Management Workflow,workflow,business-operations,compliance,,compliance,3,7,2,consent-management;gdpr;cookie-consent;privacy-preferences;opt-in-opt-out;compliance,"User consent management workflow with cookie banner, preference center, consent recording, downstream system sync, and audit trail.",business-operations/consent-management,compliance/business-operations/consent-management-workflow +container-loading-workflow,container-loading,Container Loading Workflow,workflow,logistics,uncategorized,,,3,7,2,container-loading;load-planning;weight-distribution;cube-utilization;seal-verification;ocean-freight,"Container loading workflow with load plan optimization, weight distribution, cube utilization maximization, seal application, and bill of lading generation.",logistics/container-loading,uncategorized/logistics/container-loading-workflow +content-enricher-workflow,content-enricher,Content Enricher Workflow,workflow,patterns,uncategorized,,,3,10,3,content;enricher;patterns;decision,This workflow models adding extra data from other sources.,patterns/content-enricher,uncategorized/patterns/content-enricher-workflow +cost-center-workflow,cost-center,Cost Center Workflow,workflow,finance,uncategorized,,,2,7,2,cost;center;finance;decision,This workflow models managing cost center budgets.,finance/cost-center,uncategorized/finance/cost-center-workflow +cqrs-workflow,cqrs,Cqrs Workflow,workflow,patterns,uncategorized,,,4,19,4,cqrs;command-query-separation;event-sourcing;read-model;write-model;domain-events;eventual-consistency,"CQRS (Command Query Responsibility Segregation) pattern with separate command and query paths, domain event publishing, read model synchronization, and DTO transformation.",patterns/cqrs,uncategorized/patterns/cqrs-workflow +credit-control-workflow,credit-control,Credit Control Workflow,workflow,finance,uncategorized,,,3,10,3,credit-control;credit-limit;customer-credit;credit-scoring;collections;accounts-receivable,"Customer credit control workflow with credit limit assessment, credit scoring, order hold management, collections escalation, and payment plan negotiation.",finance/credit-control,uncategorized/finance/credit-control-workflow +cross-docking-workflow,cross-docking,Cross Docking Workflow,workflow,logistics,uncategorized,,,3,10,3,cross-docking;flow-through;dock-scheduling;sortation;consolidation;just-in-time,"Cross-docking workflow with inbound scheduling, sortation by destination, outbound consolidation, and direct transfer without storage for just-in-time delivery.",logistics/cross-docking,uncategorized/logistics/cross-docking-workflow +crud-user-browser-server-workflow,crud-user-browser-server,Crud User Browser Server Workflow,workflow,patterns,uncategorized,,,2,7,2,crud;user;browser;server;patterns,"This workflow models user creates, reads, updates, and deletes data through a browser and server.",patterns/crud-user-browser-server,uncategorized/patterns/crud-user-browser-server-workflow +customs-clearance-workflow,customs-clearance,Customs Clearance Workflow,workflow,logistics,uncategorized,,,4,19,3,customs-clearance;international-trade;customs-broker;hs-codes;import-export;duties-taxes;inspection,"International customs clearance workflow with importer documentation, customs broker HS code classification, duty calculation, customs authority inspection, and clearance certificate issuance.",logistics/customs-clearance,uncategorized/logistics/customs-clearance-workflow +cycle-counting-workflow,cycle-counting,Cycle Counting Workflow,workflow,logistics,compliance,,compliance,3,10,3,cycle-counting;inventory-accuracy;abc-analysis;variance-investigation;perpetual-inventory;audit,"Inventory cycle counting workflow with ABC classification, count scheduling, variance investigation, adjustment approval, and inventory accuracy tracking.",logistics/cycle-counting,compliance/logistics/cycle-counting-workflow +damaged-goods-workflow,damaged-goods,Damaged Goods Workflow,workflow,logistics,uncategorized,,,3,7,2,damaged-goods;damage-claim;inventory-write-off;carrier-claim;disposition;loss-prevention,"Damaged goods processing workflow with damage documentation, carrier claim filing, disposition decision (salvage/dispose), inventory adjustment, and loss tracking.",logistics/damaged-goods,uncategorized/logistics/damaged-goods-workflow +data-export-workflow,data-export,Data Export Workflow,workflow,business-operations,compliance,,compliance,3,10,3,data-export;data-portability;gdpr;bulk-export;async-job;download-link,"User data export workflow with export request, async job processing, data aggregation, secure file generation, and download link delivery.",business-operations/data-export,compliance/business-operations/data-export-workflow +database-migration-workflow,database-migration,Database Migration Workflow,workflow,devops,approval,delivery,approval;delivery,4,20,4,database-migration;schema-changes;flyway;liquibase;rollback;dba-approval;maintenance-window,"Database schema migration workflow with CI testing, DBA review and approval, maintenance window scheduling, backup snapshots, migration execution, data integrity verification, and automatic rollback.",devops/database-migration,approval/devops/database-migration-workflow +dead-letter-queue-workflow,dead-letter-queue,Dead Letter Queue Workflow,workflow,patterns,uncategorized,,,3,7,2,dead-letter-queue;dlq;message-retry;poison-message;error-handling;message-queue,"Dead letter queue pattern for handling failed messages with retry exhaustion detection, DLQ routing, manual inspection, and reprocessing capability.",patterns/dead-letter-queue,uncategorized/patterns/dead-letter-queue-workflow +decision-diamond-workflow,decision-diamond,Decision Diamond Workflow,workflow,patterns,uncategorized,,,3,10,3,decision;diamond;patterns,This workflow models an if or then style branch for approval or rejection.,patterns/decision-diamond,uncategorized/patterns/decision-diamond-workflow +delivery-confirmation-workflow,delivery-confirmation,Delivery Confirmation Workflow,workflow,logistics,uncategorized,,,2,7,2,delivery-confirmation;pod;signature-capture;order-completion;customer-notification;tracking-update,"Delivery confirmation workflow with proof of delivery capture, signature collection, photo documentation, order status update, and customer notification.",logistics/delivery-confirmation,uncategorized/logistics/delivery-confirmation-workflow +deployment-rollback-workflow,deployment-rollback,Deployment Rollback Workflow,workflow,devops,incident,delivery,incident;delivery,3,10,3,deployment-rollback;version-revert;incident-response;kubernetes;helm-rollback;service-recovery,"Deployment rollback workflow with issue detection, rollback decision, previous version restoration, health verification, and post-mortem documentation.",devops/deployment-rollback,incident/devops/deployment-rollback-workflow +diversity-initiative-workflow,diversity-initiative,Diversity Initiative Workflow,workflow,hr,uncategorized,,,3,10,3,diversity;initiative;hr,This workflow models promoting workplace diversity.,hr/diversity-initiative,uncategorized/hr/diversity-initiative-workflow +dunning-flow-workflow,dunning-flow,Dunning Flow Workflow,workflow,business-operations,billing,,billing,3,10,3,dunning-flow;collections;overdue-payment;payment-reminder;account-suspension;revenue-recovery,"Dunning collection workflow with escalating reminder emails, grace period management, account suspension, and payment recovery tracking.",business-operations/dunning-flow,billing/business-operations/dunning-flow-workflow +email-campaign-workflow,email-campaign,Email Campaign Workflow,workflow,business-operations,uncategorized,,,4,13,4,email-campaign;marketing-automation;mailchimp;segmentation;a-b-testing;deliverability,"Email marketing campaign workflow with audience segmentation, A/B testing, send scheduling, deliverability monitoring, and engagement analytics.",business-operations/email-campaign,uncategorized/business-operations/email-campaign-workflow +employee-engagement-workflow,employee-engagement,Employee Engagement Workflow,workflow,hr,uncategorized,,,2,7,2,employee;engagement;hr;parallel,This workflow models measuring and improving engagement.,hr/employee-engagement,uncategorized/hr/employee-engagement-workflow +enricher-workflow,enricher,Enricher Workflow,workflow,patterns,uncategorized,,,3,10,3,enricher;patterns,This workflow models adding metadata to messages before passing them on.,patterns/enricher,uncategorized/patterns/enricher-workflow +error-retry-loop-workflow,error-retry-loop,Error Retry Loop Workflow,workflow,patterns,uncategorized,,,2,7,2,error;retry;loop;patterns,This workflow models a failed operation that retries with backoff.,patterns/error-retry-loop,uncategorized/patterns/error-retry-loop-workflow +escalation-pattern-workflow,escalation-pattern,Escalation Pattern Workflow,workflow,patterns,handoff,,handoff,3,10,3,escalation;pattern;patterns,This workflow models escalating issues to higher authority when needed.,patterns/escalation-pattern,handoff/patterns/escalation-pattern-workflow +event-driven-workflow,event-driven,Event Driven Workflow,workflow,patterns,uncategorized,,,3,10,3,event;driven;patterns,This workflow models reacting to incoming business events.,patterns/event-driven,uncategorized/patterns/event-driven-workflow +event-sourcing-workflow,event-sourcing,Event Sourcing Workflow,workflow,patterns,compliance,,compliance,4,10,3,event-sourcing;event-store;aggregate;replay;audit-log;temporal-query,"Event sourcing pattern with event capture, event store persistence, aggregate reconstruction, snapshot optimization, and temporal state queries.",patterns/event-sourcing,compliance/patterns/event-sourcing-workflow +expense-allocation-workflow,expense-allocation,Expense Allocation Workflow,workflow,finance,uncategorized,,,3,10,3,expense;allocation;finance,This workflow models allocating costs to departments.,finance/expense-allocation,uncategorized/finance/expense-allocation-workflow +expense-approval-workflow,expense-approval,Expense Approval Workflow,workflow,hr,approval,compliance,approval;compliance,3,10,3,expense-approval;travel-expenses;receipt-validation;policy-compliance;tiered-approval;reimbursement,"Employee expense approval workflow with receipt validation, policy compliance check, tiered approval based on amount, and reimbursement processing.",hr/expense-approval,approval/hr/expense-approval-workflow +expense-claim-workflow,expense-claim,Expense Claim Workflow,workflow,finance,approval,,approval,3,10,3,expense-reimbursement;employee-expenses;receipt-upload;manager-approval;finance-review;direct-deposit,"Employee expense reimbursement workflow with receipt submission, manager approval, finance review, policy compliance check, and direct deposit payment.",finance/expense-claim,approval/finance/expense-claim-workflow +fan-out-fan-in-workflow,fan-out-fan-in,Fan Out Fan In Workflow,workflow,patterns,ai-orchestration,,ai-orchestration,4,13,4,fan-out-fan-in;scatter-gather;parallel-processing;aggregation;map-reduce;concurrency,"Fan-out/fan-in pattern with work distribution to parallel workers, concurrent execution, result aggregation, and error handling for partial failures.",patterns/fan-out-fan-in,ai-orchestration/patterns/fan-out-fan-in-workflow +feature-toggle-workflow,feature-toggle,Feature Toggle Workflow,workflow,patterns,uncategorized,,,3,10,3,feature-toggle;feature-flags;dark-launch;a-b-testing;gradual-rollout;kill-switch,"Feature toggle pattern with flag configuration, user targeting rules, percentage rollouts, and instant kill-switch capability for production features.",patterns/feature-toggle,uncategorized/patterns/feature-toggle-workflow +filter-workflow,filter,Filter Workflow,workflow,patterns,uncategorized,,,4,13,4,filter;patterns;decision;loop,This workflow models removing items that do not meet criteria.,patterns/filter,uncategorized/patterns/filter-workflow +financial-reporting-workflow,financial-reporting,Financial Reporting Workflow,workflow,finance,compliance,,compliance,4,10,3,financial-reporting;gaap-compliance;income-statement;balance-sheet;cash-flow-statement;sec-filing,"Financial reporting workflow with GAAP-compliant statement preparation, management review, audit committee approval, and SEC filing for public companies.",finance/financial-reporting,compliance/finance/financial-reporting-workflow +fixed-assets-workflow,fixed-assets,Fixed Assets Workflow,workflow,finance,uncategorized,,,3,7,2,fixed-assets;asset-tracking;depreciation;capitalization;asset-disposal;physical-inventory,"Fixed asset management workflow with asset capitalization, depreciation scheduling, physical inventory verification, and asset disposal/retirement processing.",finance/fixed-assets,uncategorized/finance/fixed-assets-workflow +fleet-maintenance-workflow,fleet-maintenance,Fleet Maintenance Workflow,workflow,logistics,compliance,,compliance,3,7,2,fleet-maintenance;preventive-maintenance;vehicle-inspection;work-order;dot-compliance;telematics,"Fleet maintenance workflow with preventive maintenance scheduling, vehicle inspection, work order creation, parts ordering, and DOT compliance tracking.",logistics/fleet-maintenance,compliance/logistics/fleet-maintenance-workflow +gdpr-deletion-workflow,gdpr-deletion,Gdpr Deletion Workflow,workflow,business-operations,compliance,,compliance,4,13,4,gdpr-deletion;right-to-be-forgotten;data-privacy;pii-removal;compliance;dsar,"GDPR data deletion workflow with identity verification, data inventory scan, PII removal across systems, backup purging, and deletion confirmation.",business-operations/gdpr-deletion,compliance/business-operations/gdpr-deletion-workflow +hazmat-handling-workflow,hazmat-handling,Hazmat Handling Workflow,workflow,logistics,incident,compliance,incident;compliance,4,10,3,hazmat-handling;dangerous-goods;un-classification;sds-documentation;dot-compliance;emergency-response,"Hazardous materials handling workflow with UN classification, SDS documentation, proper labeling, certified handler assignment, and emergency response procedures.",logistics/hazmat-handling,incident/logistics/hazmat-handling-workflow +idempotent-consumer-workflow,idempotent-consumer,Idempotent Consumer Workflow,workflow,patterns,uncategorized,,,3,10,3,idempotent;consumer;patterns,This workflow models processing each message safely only once.,patterns/idempotent-consumer,uncategorized/patterns/idempotent-consumer-workflow +in-app-message-workflow,in-app-message,In App Message Workflow,workflow,business-operations,uncategorized,,,2,7,2,in-app-message;product-tours;tooltips;announcements;user-engagement;intercom,"In-app messaging workflow with trigger conditions, audience targeting, message display, user interaction tracking, and conversion measurement.",business-operations/in-app-message,uncategorized/business-operations/in-app-message-workflow +incident-response-workflow,incident-response,Incident Response Workflow,workflow,devops,incident,,incident,5,23,4,incident-management;on-call;pagerduty;war-room;severity-levels;postmortem;sre,"Production incident response workflow with severity-based routing, war room coordination, incident commander assignment, customer communication, root cause analysis, and postmortem scheduling.",devops/incident-response,incident/devops/incident-response-workflow +infrastructure-provisioning-workflow,infrastructure-provisioning,Infrastructure Provisioning Workflow,workflow,devops,delivery,,delivery,4,10,3,infrastructure-provisioning;terraform;iac;cloud-resources;gitops;state-management,"Infrastructure as Code provisioning workflow with Terraform plan, approval gates, state management, resource creation, and drift detection.",devops/infrastructure-provisioning,delivery/devops/infrastructure-provisioning-workflow +insurance-claim-workflow,insurance-claim,Insurance Claim Workflow,workflow,finance,approval,,approval,3,7,2,insurance-claim;claim-filing;adjuster-review;settlement;property-damage;liability,"Insurance claim processing workflow with incident documentation, claim filing, adjuster assignment, damage assessment, and settlement negotiation.",finance/insurance-claim,approval/finance/insurance-claim-workflow +internal-controls-workflow,internal-controls,Internal Controls Workflow,workflow,finance,compliance,,compliance,4,10,3,internal-controls;sox-compliance;control-testing;segregation-of-duties;risk-assessment;remediation,"Internal controls testing workflow with risk assessment, control design evaluation, operating effectiveness testing, deficiency identification, and remediation tracking.",finance/internal-controls,compliance/finance/internal-controls-workflow +internship-program-workflow,internship-program,Internship Program Workflow,workflow,hr,uncategorized,,,2,7,2,internship;program;hr,This workflow models managing an internship program.,hr/internship-program,uncategorized/hr/internship-program-workflow +interview-process-workflow,interview-process,Interview Process Workflow,workflow,hr,uncategorized,,,4,22,3,interview-process;hiring;phone-screen;technical-interview;onsite-panel;talent-acquisition;offer-management,"Multi-stage interview process with resume screening, phone screen, technical interview, onsite panel, team consensus decision, and offer/rejection handling.",hr/interview-process,uncategorized/hr/interview-process-workflow +inventory-receipt-workflow,inventory-receipt,Inventory Receipt Workflow,workflow,logistics,uncategorized,,,3,7,2,inventory-receipt;goods-receiving;po-matching;asn-verification;dock-scheduling;wms,"Inventory receiving workflow with ASN verification, PO matching, quantity count, damage inspection, and WMS inventory update.",logistics/inventory-receipt,uncategorized/logistics/inventory-receipt-workflow +invoice-processing-workflow,invoice-processing,Invoice Processing Workflow,workflow,finance,approval,billing,approval;billing,4,19,4,accounts-payable;invoice-automation;ocr;po-matching;approval-workflow;payment-processing;three-way-match,"Accounts payable invoice automation with OCR data extraction, three-way PO matching, tiered approval workflow, and automated payment processing with GL updates.",finance/invoice-processing,approval/finance/invoice-processing-workflow +job-posting-workflow,job-posting,Job Posting Workflow,workflow,hr,uncategorized,,,4,19,3,job-posting;job-requisition;ats;linkedin;indeed;ai-screening;talent-acquisition,"Job posting workflow with requisition approval, job description drafting, multi-channel posting (LinkedIn, Indeed, career sites), AI resume screening, and ATS candidate tracking.",hr/job-posting,uncategorized/hr/job-posting-workflow +kitting-process-workflow,kitting-process,Kitting Process Workflow,workflow,logistics,uncategorized,,,2,7,2,kitting-process;kit-assembly;bom;component-picking;value-added-services;bundling,"Kit assembly workflow with BOM explosion, component picking, assembly verification, kit labeling, and inventory conversion from components to finished kit.",logistics/kitting-process,uncategorized/logistics/kitting-process-workflow +knowledge-base-workflow,knowledge-base,Knowledge Base Workflow,workflow,business-operations,support,,support,3,13,4,knowledge-base;help-center;documentation;self-service;article-management;zendesk,"Knowledge base management workflow with article creation, review approval, SEO optimization, version control, and search analytics tracking.",business-operations/knowledge-base,support/business-operations/knowledge-base-workflow +last-mile-delivery-workflow,last-mile-delivery,Last Mile Delivery Workflow,workflow,logistics,uncategorized,,,3,7,2,last-mile-delivery;route-optimization;proof-of-delivery;delivery-exception;customer-notification;gps-tracking,"Last mile delivery workflow with route optimization, real-time GPS tracking, delivery attempt handling, proof of delivery capture, and customer notification.",logistics/last-mile-delivery,uncategorized/logistics/last-mile-delivery-workflow +load-testing-workflow,load-testing,Load Testing Workflow,workflow,devops,delivery,,delivery,4,13,4,load-testing;performance-testing;stress-testing;k6;jmeter;capacity-planning,"Load testing workflow with test scenario design, gradual ramp-up, performance metrics collection, bottleneck identification, and capacity recommendations.",devops/load-testing,delivery/devops/load-testing-workflow +materialized-view-workflow,materialized-view,Materialized View Workflow,workflow,patterns,uncategorized,,,4,13,4,materialized;view;patterns;decision;loop,This workflow models serving queries from a precomputed view.,patterns/materialized-view,uncategorized/patterns/materialized-view-workflow +message-queue-workflow,message-queue,Message Queue Workflow,workflow,patterns,uncategorized,,,3,10,3,message;queue;patterns;decision,This workflow models asynchronous processing of work via a queue.,patterns/message-queue,uncategorized/patterns/message-queue-workflow +monitoring-alert-workflow,monitoring-alert,Monitoring Alert Workflow,workflow,devops,incident,,incident,3,10,3,monitoring-alerting;prometheus;pagerduty;threshold-alerts;anomaly-detection;on-call,"Monitoring and alerting workflow with metric collection, threshold evaluation, alert routing, escalation policies, and incident creation.",devops/monitoring-alert,incident/devops/monitoring-alert-workflow +monthly-close-workflow,monthly-close,Monthly Close Workflow,workflow,finance,uncategorized,,,4,22,4,monthly-close;financial-reporting;accounting;reconciliation;trial-balance;period-close,"Corporate month-end financial close process including transaction posting, bank reconciliation, accruals, depreciation, trial balance validation, and financial statement generation.",finance/monthly-close,uncategorized/finance/monthly-close-workflow +nested-decisions-workflow,nested-decisions,Nested Decisions Workflow,workflow,patterns,uncategorized,,,3,10,3,nested;decisions;patterns;decision;loop,This workflow models multiple layers of decisions before completion.,patterns/nested-decisions,uncategorized/patterns/nested-decisions-workflow +normalizer-workflow,normalizer,Normalizer Workflow,workflow,patterns,uncategorized,,,4,13,4,normalizer;patterns,This workflow models converting varied inputs to a standard format.,patterns/normalizer,uncategorized/patterns/normalizer-workflow +notification-pattern-workflow,notification-pattern,Notification Pattern Workflow,workflow,patterns,uncategorized,,,2,7,2,notification;pattern;patterns,This workflow models sending alerts via multiple channels.,patterns/notification-pattern,uncategorized/patterns/notification-pattern-workflow +oauth-flow-workflow,oauth-flow,Oauth Flow Workflow,workflow,business-operations,approval,security,approval;security,4,13,4,oauth-flow;oauth2;authorization-code;token-exchange;sso;third-party-auth,"OAuth 2.0 authorization code flow with redirect handling, code exchange, token storage, refresh token rotation, and scope management.",business-operations/oauth-flow,approval/business-operations/oauth-flow-workflow +offboarding-workflow,offboarding,Offboarding Workflow,workflow,hr,handoff,offboarding,handoff;offboarding,4,10,3,employee-offboarding;exit-interview;access-revocation;asset-return;knowledge-transfer;final-paycheck,"Employee offboarding workflow with exit interview, knowledge transfer, asset collection, access revocation, final pay processing, and benefits continuation.",hr/offboarding,handoff/hr/offboarding-workflow +on-call-rotation-workflow,on-call-rotation,On Call Rotation Workflow,workflow,devops,handoff,incident;security,handoff;incident;security,3,13,4,on-call-rotation;incident-management;pagerduty;escalation;schedule-management;handoff,"On-call rotation workflow with schedule creation, shift handoffs, override management, escalation policies, and fair rotation distribution.",devops/on-call-rotation,handoff/devops/on-call-rotation-workflow +onboarding-workflow,onboarding,Onboarding Workflow,workflow,hr,onboarding,delivery,onboarding;delivery,4,20,3,employee-onboarding;new-hire;hr-workflow;background-check;it-provisioning;benefits-enrollment,"Complete employee onboarding workflow covering offer acceptance, HR record creation, benefits enrollment, background check verification, IT account provisioning, equipment setup, and first day orientation.",hr/onboarding,onboarding/hr/onboarding-workflow +packing-process-workflow,packing-process,Packing Process Workflow,workflow,logistics,uncategorized,,,2,7,2,order-packing;box-selection;packing-slip;weight-verification;cartonization;fulfillment,"Order packing workflow with carton selection, item verification, packing slip insertion, weight check, and package sealing for shipment.",logistics/packing-process,uncategorized/logistics/packing-process-workflow +parallel-execution-workflow,parallel-execution,Parallel Execution Workflow,workflow,patterns,uncategorized,,,4,13,4,parallel;execution;patterns;loop,This workflow models multiple tasks that run at the same time.,patterns/parallel-execution,uncategorized/patterns/parallel-execution-workflow +payment-failure-workflow,payment-failure,Payment Failure Workflow,workflow,business-operations,billing,,billing,3,7,2,payment-failure;dunning;retry-logic;card-decline;revenue-recovery;stripe,"Failed payment recovery workflow with smart retry scheduling, dunning email sequence, payment method update prompts, and involuntary churn prevention.",business-operations/payment-failure,billing/business-operations/payment-failure-workflow +payment-run-workflow,payment-run,Payment Run Workflow,workflow,finance,handoff,approval;billing,handoff;approval;billing,4,18,3,payment-run;accounts-payable;ach-payments;check-run;dual-approval;bank-transfer;vendor-payments,"Accounts payable payment run workflow with batch creation, tiered approval (single/dual based on amount), ACH file generation, check printing, and vendor record updates.",finance/payment-run,handoff/finance/payment-run-workflow +payroll-processing-workflow,payroll-processing,Payroll Processing Workflow,workflow,finance,compliance,,compliance,5,24,4,payroll-processing;salary-calculation;tax-withholding;fica;ach-direct-deposit;benefits-deductions;compliance,"Complete payroll processing workflow with timesheet collection, gross pay calculation, overtime, tax withholding (federal, state, FICA), benefits deductions, compliance validation, and ACH direct deposit.",finance/payroll-processing,compliance/finance/payroll-processing-workflow +performance-review-workflow,performance-review,Performance Review Workflow,workflow,hr,approval,,approval,4,10,3,performance-review;annual-evaluation;goal-setting;360-feedback;calibration;merit-increase,"Annual performance review workflow with self-assessment, manager evaluation, 360 feedback collection, calibration sessions, and merit increase recommendations.",hr/performance-review,approval/hr/performance-review-workflow +personalization-engine-workflow,personalization-engine,Personalization Engine Workflow,workflow,business-operations,uncategorized,,,4,20,3,make-com;personalization;segment;braze;ml-recommendations;content-delivery;marketing-automation,"Make.com automation scenario for real-time personalization using Segment events, ML recommendation API, and Braze campaign delivery across email and push channels.",business-operations/personalization-engine,uncategorized/business-operations/personalization-engine-workflow +picking-process-workflow,picking-process,Picking Process Workflow,workflow,logistics,uncategorized,,,3,10,3,order-picking;warehouse-management;pick-list;batch-picking;wave-picking;wms,"Warehouse order picking workflow with pick list generation, zone routing, batch picking optimization, barcode scanning verification, and pick completion confirmation.",logistics/picking-process,uncategorized/logistics/picking-process-workflow +plan-downgrade-workflow,plan-downgrade,Plan Downgrade Workflow,workflow,business-operations,billing,delivery,billing;delivery,3,13,4,plan-downgrade;retention;feature-restriction;data-migration;churn-prevention;billing,"Subscription plan downgrade workflow with retention offer, feature restriction warning, data migration handling, and end-of-period scheduling.",business-operations/plan-downgrade,billing/business-operations/plan-downgrade-workflow +plan-upgrade-workflow,plan-upgrade,Plan Upgrade Workflow,workflow,business-operations,billing,,billing,3,10,3,plan-upgrade;upsell;proration;feature-unlock;expansion-revenue;billing,"Subscription plan upgrade workflow with feature comparison, proration calculation, immediate feature unlock, and billing adjustment.",business-operations/plan-upgrade,billing/business-operations/plan-upgrade-workflow +polling-pattern-workflow,polling-pattern,Polling Pattern Workflow,workflow,patterns,uncategorized,,,4,13,4,polling;pattern;patterns;loop,This workflow models periodically checking status until work is done.,patterns/polling-pattern,uncategorized/patterns/polling-pattern-workflow +process-manager-workflow,process-manager,Process Manager Workflow,workflow,patterns,uncategorized,,,3,10,3,process;manager;patterns,This workflow models orchestrating multiple services to complete a process.,patterns/process-manager,uncategorized/patterns/process-manager-workflow +procurement-card-workflow,procurement-card,Procurement Card Workflow,workflow,finance,uncategorized,,,3,10,3,procurement;card;finance,This workflow models managing company credit cards.,finance/procurement-card,uncategorized/finance/procurement-card-workflow +promotion-process-workflow,promotion-process,Promotion Process Workflow,workflow,hr,uncategorized,,,3,7,2,promotion-process;career-advancement;job-leveling;title-change;compensation-adjustment;succession-planning,"Employee promotion workflow with performance validation, job level assessment, compensation adjustment, title change, and announcement coordination.",hr/promotion-process,uncategorized/hr/promotion-process-workflow +pto-request-workflow,pto-request,Pto Request Workflow,workflow,hr,approval,,approval,2,7,2,pto-request;time-off;vacation;leave-management;manager-approval;accrual-balance,"PTO request workflow with balance verification, manager approval, calendar blocking, and team coverage check before approval.",hr/pto-request,approval/hr/pto-request-workflow +pub-sub-workflow,pub-sub,Pub Sub Workflow,workflow,patterns,uncategorized,,,4,13,4,pub;sub;patterns,This workflow models one publisher notifying many subscribers of events.,patterns/pub-sub,uncategorized/patterns/pub-sub-workflow +purchase-order-workflow,purchase-order,Purchase Order Workflow,workflow,finance,approval,ai-orchestration,approval;ai-orchestration,4,22,3,purchase-order;procurement;requisition;vendor-sourcing;competitive-bidding;tiered-approval;budget-validation,"Procurement purchase order workflow with requisition creation, budget validation, vendor sourcing, competitive bidding, and tiered approval routing based on amount thresholds.",finance/purchase-order,approval/finance/purchase-order-workflow +push-notification-workflow,push-notification,Push Notification Workflow,workflow,business-operations,uncategorized,,,3,10,3,push-notification;mobile-engagement;firebase-fcm;apns;segmentation;deep-linking,"Mobile push notification workflow with audience targeting, platform routing (iOS/Android), delivery tracking, and engagement analytics.",business-operations/push-notification,uncategorized/business-operations/push-notification-workflow +put-away-process-workflow,put-away-process,Put Away Process Workflow,workflow,logistics,uncategorized,,,2,7,2,put-away;warehouse-storage;location-assignment;slotting;wms;inventory-placement,"Warehouse put-away workflow with location assignment, slotting optimization, forklift routing, barcode confirmation, and WMS location update.",logistics/put-away-process,uncategorized/logistics/put-away-process-workflow +quality-inspection-workflow,quality-inspection,Quality Inspection Workflow,workflow,logistics,uncategorized,,,3,10,3,quality-inspection;incoming-inspection;aql-sampling;defect-tracking;supplier-quality;hold-release,"Incoming quality inspection workflow with AQL sampling, defect classification, hold/release decision, supplier notification, and quality metrics tracking.",logistics/quality-inspection,uncategorized/logistics/quality-inspection-workflow +rate-limiter-workflow,rate-limiter,Rate Limiter Workflow,workflow,patterns,uncategorized,,,4,13,4,rate;limiter;patterns,This workflow models preventing too many requests from being processed.,patterns/rate-limiter,uncategorized/patterns/rate-limiter-workflow +reference-check-workflow,reference-check,Reference Check Workflow,workflow,hr,uncategorized,,,3,10,3,reference-check;employment-verification;professional-references;hiring-decision;candidate-vetting;feedback-collection,"Professional reference check workflow with reference collection, outreach scheduling, structured interview questions, feedback documentation, and hiring recommendation.",hr/reference-check,uncategorized/hr/reference-check-workflow +referral-program-workflow,referral-program,Referral Program Workflow,workflow,business-operations,uncategorized,,,3,13,4,referral-program;viral-growth;referral-tracking;reward-fulfillment;affiliate;word-of-mouth,"Customer referral program workflow with unique link generation, referral tracking, conversion validation, and dual-sided reward fulfillment.",business-operations/referral-program,uncategorized/business-operations/referral-program-workflow +relocation-assistance-workflow,relocation-assistance,Relocation Assistance Workflow,workflow,hr,uncategorized,,,3,10,3,relocation;assistance;hr;decision,This workflow models helping employees relocate.,hr/relocation-assistance,uncategorized/hr/relocation-assistance-workflow +reorder-process-workflow,reorder-process,Reorder Process Workflow,workflow,logistics,uncategorized,,,3,7,2,reorder-process;reorder-point;safety-stock;eoq;demand-planning;auto-replenishment,"Inventory reorder workflow with reorder point monitoring, economic order quantity calculation, safety stock consideration, and automatic purchase requisition generation.",logistics/reorder-process,uncategorized/logistics/reorder-process-workflow +request-reply-workflow,request-reply,Request Reply Workflow,workflow,patterns,uncategorized,,,2,7,2,request;reply;patterns,This workflow models a synchronous request that waits for a reply.,patterns/request-reply,uncategorized/patterns/request-reply-workflow +retry-with-backoff-workflow,retry-with-backoff,Retry With Backoff Workflow,workflow,patterns,uncategorized,,,4,20,3,retry-pattern;exponential-backoff;fault-tolerance;api-resilience;transient-errors;http-retry;jitter,"Exponential backoff retry pattern for API calls with configurable retry limits, delay calculation, retryable error detection, and graceful degradation on permanent failures.",patterns/retry-with-backoff,uncategorized/patterns/retry-with-backoff-workflow +returns-processing-workflow,returns-processing,Returns Processing Workflow,workflow,logistics,billing,,billing,3,7,2,returns-processing;rma;refund;restocking;quality-inspection;reverse-logistics,"Customer returns processing workflow with RMA generation, return receipt, quality inspection, disposition decision, and refund or exchange processing.",logistics/returns-processing,billing/logistics/returns-processing-workflow +reverse-logistics-workflow,reverse-logistics,Reverse Logistics Workflow,workflow,logistics,uncategorized,,,4,10,3,reverse-logistics;product-returns;refurbishment;recycling;disposition;sustainability,"Reverse logistics workflow with return authorization, product grading, refurbishment decision, recycling coordination, and secondary market disposition.",logistics/reverse-logistics,uncategorized/logistics/reverse-logistics-workflow +review-collection-workflow,review-collection,Review Collection Workflow,workflow,business-operations,approval,,approval,2,7,2,review-collection;customer-feedback;nps;ratings;social-proof;testimonials,"Customer review collection workflow with post-purchase trigger, review request email, rating submission, moderation, and public display.",business-operations/review-collection,approval/business-operations/review-collection-workflow +router-workflow,router,Router Workflow,workflow,patterns,uncategorized,,,3,10,3,router;patterns;decision,This workflow models routing messages based on their content.,patterns/router,uncategorized/patterns/router-workflow +routing-slip-workflow,routing-slip,Routing Slip Workflow,workflow,patterns,handoff,,handoff,4,13,4,routing;slip;patterns,This workflow models having messages carry their own routing instructions.,patterns/routing-slip,handoff/patterns/routing-slip-workflow +saga-pattern-workflow,saga-pattern,Saga Pattern Workflow,workflow,patterns,delivery,ai-orchestration,delivery;ai-orchestration,5,20,4,saga-pattern;distributed-transactions;microservices;compensation;orchestration;eventual-consistency;rollback,"Saga orchestration pattern for distributed transactions across Order, Payment, and Shipping services with automatic compensation rollback on failures.",patterns/saga-pattern,delivery/patterns/saga-pattern-workflow +salary-increase-workflow,salary-increase,Salary Increase Workflow,workflow,hr,approval,,approval,3,10,3,salary-increase;compensation;merit-raise;market-adjustment;budget-approval;comp-ratio,"Salary increase workflow with market analysis, comp ratio review, budget validation, tiered approval based on increase percentage, and payroll system update.",hr/salary-increase,approval/hr/salary-increase-workflow +search-optimization-workflow,search-optimization,Search Optimization Workflow,workflow,business-operations,uncategorized,,,4,13,4,search-optimization;elasticsearch;relevance-tuning;query-analysis;algolia;search-analytics,"Search optimization workflow with query analysis, relevance tuning, synonym management, click-through tracking, and A/B testing of ranking algorithms.",business-operations/search-optimization,uncategorized/business-operations/search-optimization-workflow +secret-rotation-workflow,secret-rotation,Secret Rotation Workflow,workflow,devops,security,,security,4,18,3,secret-rotation;vault;kubernetes-secrets;api-keys;database-passwords;certificates;security,"Automated secret rotation workflow with HashiCorp Vault for API keys, database passwords, and certificates including Kubernetes secret updates and rolling service restarts.",devops/secret-rotation,security/devops/secret-rotation-workflow +security-scan-workflow,security-scan,Security Scan Workflow,workflow,devops,security,,security,3,10,3,security-scanning;sast;dast;dependency-check;snyk;devsecops,"Security scanning workflow with SAST, DAST, dependency vulnerability scanning, finding triage, and remediation tracking in CI/CD pipeline.",devops/security-scan,security/devops/security-scan-workflow +shipping-process-workflow,shipping-process,Shipping Process Workflow,workflow,logistics,security,,security,3,10,3,shipping-process;order-fulfillment;carrier-selection;label-generation;tracking-number;dispatch,"Order shipping workflow with carrier selection, rate shopping, label generation, tracking number assignment, and dispatch confirmation.",logistics/shipping-process,security/logistics/shipping-process-workflow +sms-verification-workflow,sms-verification,Sms Verification Workflow,workflow,business-operations,security,,security,3,13,4,sms-verification;otp;twilio;phone-verification;2fa;fraud-prevention,"SMS phone verification workflow with OTP generation, rate limiting, code validation, retry handling, and verification status tracking.",business-operations/sms-verification,security/business-operations/sms-verification-workflow +snapshot-pattern-workflow,snapshot-pattern,Snapshot Pattern Workflow,workflow,patterns,uncategorized,,,2,7,2,snapshot;pattern;patterns;decision;loop,This workflow models taking periodic snapshots of important state.,patterns/snapshot-pattern,uncategorized/patterns/snapshot-pattern-workflow +state-machine-workflow,state-machine,State Machine Workflow,workflow,patterns,uncategorized,,,4,13,4,state;machine;patterns;parallel,This workflow models tracking object state changes over time.,patterns/state-machine,uncategorized/patterns/state-machine-workflow +stock-transfer-workflow,stock-transfer,Stock Transfer Workflow,workflow,logistics,handoff,,handoff,3,10,3,stock-transfer;inventory-movement;location-transfer;bin-to-bin;wms;inventory-rebalancing,"Internal stock transfer workflow with transfer request, source location pick, destination put-away, and inventory record updates across locations.",logistics/stock-transfer,handoff/logistics/stock-transfer-workflow +strangler-fig-workflow,strangler-fig,Strangler Fig Workflow,workflow,patterns,uncategorized,,,2,7,2,strangler;fig;patterns;decision,This workflow models gradually replacing an old system with a new one.,patterns/strangler-fig,uncategorized/patterns/strangler-fig-workflow +subscription-lifecycle-workflow,subscription-lifecycle,Subscription Lifecycle Workflow,workflow,business-operations,billing,,billing,4,10,3,subscription-lifecycle;saas;trial-conversion;renewal;churn-prevention;stripe,"SaaS subscription lifecycle workflow with trial signup, conversion nurturing, payment processing, renewal management, and churn prevention campaigns.",business-operations/subscription-lifecycle,billing/business-operations/subscription-lifecycle-workflow +support-ticket-workflow,support-ticket,Support Ticket Workflow,workflow,business-operations,handoff,support,handoff;support,3,10,3,support-ticket;helpdesk;zendesk;sla;ticket-routing;customer-service,"Customer support ticket workflow with auto-categorization, SLA tracking, agent assignment, escalation rules, and satisfaction survey.",business-operations/support-ticket,handoff/business-operations/support-ticket-workflow +tax-filing-workflow,tax-filing,Tax Filing Workflow,workflow,finance,compliance,,compliance,4,19,3,tax-filing;corporate-tax;tax-calculation;irs-efile;tax-credits;deductions;compliance,"Corporate tax filing workflow with taxable income calculation, deductions, tax credits, variance review, and electronic or paper filing to IRS with receipt confirmation.",finance/tax-filing,compliance/finance/tax-filing-workflow +termination-process-workflow,termination-process,Termination Process Workflow,workflow,hr,approval,offboarding,approval;offboarding,4,20,3,employee-termination;offboarding;separation-agreement;final-pay;cobra;severance;legal-review,"Employee termination workflow handling voluntary and involuntary separations with legal review, separation agreements, final pay calculation, COBRA notices, and severance processing.",hr/termination-process,approval/hr/termination-process-workflow +timeout-pattern-workflow,timeout-pattern,Timeout Pattern Workflow,workflow,patterns,uncategorized,,,4,13,4,timeout;pattern;patterns,This workflow models an operation that times out after a delay.,patterns/timeout-pattern,uncategorized/patterns/timeout-pattern-workflow +training-enrollment-workflow,training-enrollment,Training Enrollment Workflow,workflow,hr,compliance,,compliance,2,7,2,training-enrollment;learning-management;lms;professional-development;compliance-training;certification,"Training enrollment workflow with course catalog browsing, manager approval, LMS registration, completion tracking, and certification management.",hr/training-enrollment,compliance/hr/training-enrollment-workflow +transactional-outbox-workflow,transactional-outbox,Transactional Outbox Workflow,workflow,patterns,uncategorized,,,4,13,4,transactional;outbox;patterns;parallel,This workflow models writing data and publishing messages in one transaction.,patterns/transactional-outbox,uncategorized/patterns/transactional-outbox-workflow +transform-workflow,transform,Transform Workflow,workflow,patterns,uncategorized,,,2,7,2,transform;patterns,This workflow models converting messages into a new shape.,patterns/transform,uncategorized/patterns/transform-workflow +treasury-management-workflow,treasury-management,Treasury Management Workflow,workflow,finance,uncategorized,,,3,7,2,treasury-management;cash-pooling;fx-hedging;investment-portfolio;bank-relationships;liquidity,"Corporate treasury management workflow with cash pooling, FX exposure hedging, short-term investment decisions, and bank relationship management.",finance/treasury-management,uncategorized/finance/treasury-management-workflow +two-factor-setup-workflow,two-factor-setup,Two Factor Setup Workflow,workflow,business-operations,onboarding,security,onboarding;security,2,7,2,two-factor-auth;mfa;totp;authenticator-app;security;account-protection,"Two-factor authentication setup workflow with method selection (TOTP/SMS), QR code generation, backup codes, and verification confirmation.",business-operations/two-factor-setup,onboarding/business-operations/two-factor-setup-workflow +user-onboarding-workflow,user-onboarding,User Onboarding Workflow,workflow,business-operations,onboarding,,onboarding,2,7,2,user-onboarding;activation;product-tour;welcome-email;first-time-user;time-to-value,"New user onboarding workflow with welcome email, profile setup, product tour, first action prompt, and activation milestone tracking.",business-operations/user-onboarding,onboarding/business-operations/user-onboarding-workflow +user-segmentation-workflow,user-segmentation,User Segmentation Workflow,workflow,business-operations,uncategorized,,,2,7,2,user-segmentation;audience-targeting;behavioral-cohorts;customer-segments;segment;marketing-automation,"User segmentation workflow with attribute collection, behavioral event tracking, segment rule definition, dynamic membership, and downstream sync.",business-operations/user-segmentation,uncategorized/business-operations/user-segmentation-workflow +validator-workflow,validator,Validator Workflow,workflow,patterns,uncategorized,,,2,7,2,validator;patterns;parallel,This workflow models checking that incoming data is valid.,patterns/validator,uncategorized/patterns/validator-workflow +vendor-onboarding-workflow,vendor-onboarding,Vendor Onboarding Workflow,workflow,finance,onboarding,billing;compliance,onboarding;billing;compliance,4,19,3,vendor-onboarding;supplier-management;w9-verification;insurance-compliance;background-check;payment-terms;procurement,"Vendor onboarding workflow with application review, W-9/W-8BEN verification, insurance certificate validation, background checks, and compliance approval before vendor activation.",finance/vendor-onboarding,onboarding/finance/vendor-onboarding-workflow +vulnerability-patch-workflow,vulnerability-patch,Vulnerability Patch Workflow,workflow,devops,security,compliance;delivery,security;compliance;delivery,4,19,3,vulnerability-management;security-patching;cve-triage;cvss-scoring;patch-testing;rollback;compliance,"Security vulnerability patching workflow with CVE scanning, severity-based triage (critical/high/medium), patch testing, staging deployment, and production rollout with rollback capability.",devops/vulnerability-patch,security/devops/vulnerability-patch-workflow +warehouse-transfer-workflow,warehouse-transfer,Warehouse Transfer Workflow,workflow,logistics,handoff,,handoff,3,10,3,warehouse-transfer;inter-facility;transfer-order;in-transit-inventory;network-optimization;distribution,"Inter-warehouse transfer workflow with transfer order creation, shipping from source DC, in-transit tracking, and receiving at destination warehouse.",logistics/warehouse-transfer,handoff/logistics/warehouse-transfer-workflow +webhook-integration-workflow,webhook-integration,Webhook Integration Workflow,workflow,business-operations,uncategorized,,,2,7,2,webhook;event-driven;http-callback;integration;retry-logic;payload-signing,"Webhook integration workflow with endpoint registration, payload signing, delivery attempt, retry with backoff, and delivery status tracking.",business-operations/webhook-integration,uncategorized/business-operations/webhook-integration-workflow +webhook-pattern-workflow,webhook-pattern,Webhook Pattern Workflow,workflow,patterns,uncategorized,,,2,7,2,webhook;pattern;patterns;decision;loop,This workflow models an HTTP callback when an event occurs.,patterns/webhook-pattern,uncategorized/patterns/webhook-pattern-workflow +webinar-registration-workflow,webinar-registration,Webinar Registration Workflow,workflow,business-operations,onboarding,,onboarding,3,10,3,webinar;event-registration;zoom;calendar-invite;reminder-sequence;lead-capture,"Webinar registration workflow with signup form, calendar invite, reminder email sequence, attendance tracking, and post-event follow-up.",business-operations/webinar-registration,onboarding/business-operations/webinar-registration-workflow +yearly-audit-workflow,yearly-audit,Yearly Audit Workflow,workflow,finance,compliance,,compliance,4,10,3,annual-audit;external-auditors;sox-compliance;financial-statements;audit-findings;management-letter,"Annual financial audit workflow with external auditor engagement, document preparation, fieldwork coordination, findings remediation, and management letter response.",finance/yearly-audit,compliance/finance/yearly-audit-workflow +shopify-universal-commerce-protocol,shopify-universal-commerce-protocol,Shopify Universal Commerce Protocol,workflow,business-operations,billing,agentic,billing;agentic,4,47,5,shopify;ucp;universal-commerce-protocol;agentic-commerce;ai-shopping;chatgpt;e-commerce;checkout;payment,"End-to-end agentic commerce workflow showing how an AI assistant (ChatGPT) orchestrates product search, checkout, and payment through Shopify's Universal Commerce Protocol (UCP) gateway, enabling conversational shopping experiences.",business-operations/shopify-universal-commerce-protocol,billing/business-operations/shopify-universal-commerce-protocol +microservices-api-gateway-architecture,microservices-api-gateway-architecture,Microservices API Gateway Architecture,architecture,Architecture,security,mcp,security;mcp,4,17,3,microservices;api-gateway;jwt-authentication;rate-limiting;service-discovery;load-balancing;architecture-diagram;distributed-systems,"A microservices API gateway architecture diagram showing request routing, JWT authentication, rate limiting, service discovery, and response aggregation across distributed backend services. This template models the entry point for all client traffic in a microservices ecosystem, enforcing security policies before requests reach internal services. Ideal for platform engineers designing scalable API infrastructure with centralized cross-cutting concerns.",,security/architecture/microservices-api-gateway-architecture +microservices-service-mesh-architecture,microservices-service-mesh-architecture,Microservices Service Mesh Architecture,architecture,Architecture,mcp,,mcp,4,18,3,service-mesh;istio;linkerd;mtls;sidecar-proxy;distributed-tracing;traffic-management;architecture-diagram,"A service mesh architecture diagram with Istio or Linkerd sidecar proxies handling mTLS encryption, traffic policies, circuit breaking, and distributed tracing across microservices. This template visualizes how a service mesh abstracts networking concerns away from application code, enabling zero-trust communication between services. Essential for teams adopting service mesh infrastructure to improve observability and security.",,mcp/architecture/microservices-service-mesh-architecture +microservices-database-per-service-architecture,microservices-database-per-service-architecture,Microservices Database-Per-Service Architecture,architecture,Architecture,uncategorized,,,4,16,4,database-per-service;polyglot-persistence;microservices;kafka;event-driven;data-isolation;eventual-consistency;architecture-diagram,"A database-per-service architecture diagram where each microservice owns its dedicated data store, with event-driven synchronization via Kafka for cross-service data consistency. This template demonstrates the core microservices data isolation principle, showing how PostgreSQL and MongoDB coexist in a polyglot persistence strategy. Critical for architects enforcing service autonomy while maintaining eventual consistency.",,uncategorized/architecture/microservices-database-per-service-architecture +microservices-decomposition-by-business-capability,microservices-decomposition-by-business-capability,Microservices Decomposition by Business Capability,architecture,Architecture,uncategorized,,,4,17,5,microservices-decomposition;business-capability;bff;domain-driven-design;service-boundaries;monolith-to-microservices;architecture-diagram,"A microservices decomposition architecture diagram organized by business capabilities: Identity, Product Catalog, Pricing, and Order Fulfillment, each with independent data stores and APIs. This template shows how to break a monolith into services aligned with business domains, using a Backend-for-Frontend (BFF) pattern for client-specific aggregation. Useful for architects planning domain-driven microservice boundaries.",,uncategorized/architecture/microservices-decomposition-by-business-capability +microservices-strangler-fig-migration,microservices-strangler-fig-migration,Microservices Strangler Fig Migration Architecture,architecture,Architecture,delivery,,delivery,4,16,4,strangler-fig;legacy-migration;monolith-decomposition;anti-corruption-layer;incremental-migration;modernization;architecture-diagram,"A strangler fig migration architecture diagram showing the incremental replacement of a legacy monolith with new microservices, using a routing layer to split traffic between old and new systems. This template models the proven migration strategy where new features are built as microservices while legacy endpoints are gradually retired. Essential for teams modernizing legacy systems without risky big-bang rewrites.",,delivery/architecture/microservices-strangler-fig-migration +microservices-service-discovery-architecture,microservices-service-discovery-architecture,Microservices Service Discovery Architecture,architecture,Architecture,handoff,,handoff,3,16,3,service-discovery;consul;eureka;health-check;client-side-load-balancing;service-registry;dynamic-routing;architecture-diagram,"A service discovery architecture diagram with Consul or Eureka registry, client-side load balancing, health check heartbeats, and automatic instance registration and deregistration. This template visualizes how microservices dynamically locate each other without hardcoded endpoints, enabling elastic scaling and self-healing infrastructure. Key for platform teams building resilient service-to-service communication.",,handoff/architecture/microservices-service-discovery-architecture +microservices-sidecar-pattern-architecture,microservices-sidecar-pattern-architecture,Microservices Sidecar Pattern Architecture,architecture,Architecture,mcp,,mcp,4,13,3,sidecar-pattern;envoy-proxy;kubernetes;container-pattern;observability;control-plane;cloud-native;architecture-diagram,"A sidecar pattern architecture diagram showing Envoy proxy, log collector, and config watcher sidecars running alongside application containers in a Kubernetes pod, with a control plane managing configuration. This template demonstrates how auxiliary concerns like logging, monitoring, and configuration are deployed as co-located containers. Foundational for teams adopting cloud-native container orchestration patterns.",,mcp/architecture/microservices-sidecar-pattern-architecture +microservices-backend-for-frontend-architecture,microservices-backend-for-frontend-architecture,Microservices Backend-for-Frontend (BFF) Architecture,architecture,Architecture,uncategorized,,,3,12,3,backend-for-frontend;bff-pattern;mobile-api;web-api;api-aggregation;payload-optimization;microservices;architecture-diagram,"A Backend-for-Frontend architecture diagram with separate BFF layers for web and mobile clients, each optimizing API responses for their specific platform while sharing common backend microservices. This template shows how to avoid one-size-fits-all APIs by tailoring data aggregation and payload optimization per client type. Recommended for teams serving multiple frontend platforms from a shared microservices backend.",,uncategorized/architecture/microservices-backend-for-frontend-architecture +event-driven-publish-subscribe-architecture,event-driven-publish-subscribe-architecture,Event-Driven Publish-Subscribe Architecture,architecture,Architecture,uncategorized,,,4,17,3,publish-subscribe;event-driven;kafka;rabbitmq;message-broker;fan-out;dead-letter-queue;architecture-diagram,"An event-driven publish-subscribe architecture diagram with Kafka or RabbitMQ message broker, event serialization, topic partitioning, fan-out delivery to multiple consumers, and dead letter queue error handling. This template models the foundational async messaging pattern where producers and consumers are fully decoupled through a message broker. Essential for architects building loosely coupled, scalable event-driven systems.",,uncategorized/architecture/event-driven-publish-subscribe-architecture +event-driven-event-sourcing-architecture,event-driven-event-sourcing-architecture,Event-Driven Event Sourcing Architecture,architecture,Architecture,uncategorized,,,4,18,4,event-sourcing;immutable-events;event-store;projections;snapshot;aggregate;temporal-query;architecture-diagram,"An event sourcing architecture diagram where all state changes are stored as an immutable sequence of domain events, with read projections built from the event stream and snapshot optimization for fast aggregate loading. This template shows how event sourcing eliminates data loss by preserving the complete history of every state transition. Critical for systems requiring full audit trails, temporal queries, and event replay capabilities.",,uncategorized/architecture/event-driven-event-sourcing-architecture +event-driven-cqrs-with-event-store-architecture,event-driven-cqrs-with-event-store-architecture,Event-Driven CQRS with Event Store Architecture,architecture,Architecture,uncategorized,,,4,18,4,cqrs;event-store;command-query-separation;read-model;write-model;projector;eventual-consistency;architecture-diagram,"A CQRS architecture diagram combining separate command and query APIs with an event bus for asynchronous read model synchronization, including projectors that build denormalized views from domain events. This template demonstrates the full CQRS+ES stack where writes go through domain validation and reads are served from optimized materialized views. Ideal for high-throughput systems where read and write workloads have fundamentally different scaling requirements.",,uncategorized/architecture/event-driven-cqrs-with-event-store-architecture +event-driven-choreography-architecture,event-driven-choreography-architecture,Event-Driven Choreography Architecture,architecture,Architecture,uncategorized,,,4,19,5,choreography;event-driven;decentralized-coordination;domain-events;microservices;autonomous-services;pub-sub;architecture-diagram,"An event-driven choreography architecture diagram where microservices coordinate through events without a central orchestrator, with Order, Payment, Inventory, and Shipping services reacting to each other's domain events. This template models the decentralized coordination pattern where each service knows only its own responsibilities and publishes events for others to consume. Best for teams favoring autonomous services over centralized workflow control.",,uncategorized/architecture/event-driven-choreography-architecture +event-driven-event-streaming-pipeline-architecture,event-driven-event-streaming-pipeline-architecture,Event-Driven Streaming Pipeline Architecture,architecture,Architecture,delivery,,delivery,4,18,4,event-streaming;kafka;apache-flink;stream-processing;real-time-analytics;iot;data-pipeline;architecture-diagram,"A real-time event streaming pipeline architecture diagram with IoT sensors, application logs, and clickstream data flowing through Kafka into Apache Flink for window aggregation, anomaly detection, and multi-sink output to data lakes and dashboards. This template visualizes end-to-end stream processing from ingestion through transformation to storage and alerting. Essential for data engineers building real-time analytics and monitoring platforms.",,delivery/architecture/event-driven-event-streaming-pipeline-architecture +event-driven-domain-events-architecture,event-driven-domain-events-architecture,Event-Driven Domain Events Architecture,architecture,Architecture,security,,security,4,17,4,domain-events;ddd;aggregate-root;bounded-context;event-dispatcher;integration-events;domain-driven-design;architecture-diagram,"A domain events architecture diagram showing how aggregate roots raise domain events that are dispatched both in-process to local handlers and cross-boundary to integration event consumers in other bounded contexts. This template models the DDD event pattern where domain logic triggers side effects through a clean event dispatcher, maintaining separation between domain and infrastructure concerns. Key for teams implementing Domain-Driven Design with event-based integration.",,security/architecture/event-driven-domain-events-architecture +event-driven-cdc-change-data-capture-architecture,event-driven-cdc-change-data-capture-architecture,Event-Driven CDC (Change Data Capture) Architecture,architecture,Architecture,uncategorized,,,4,17,4,change-data-capture;cdc;debezium;transaction-log;kafka-connect;data-synchronization;dual-write;architecture-diagram,"A Change Data Capture architecture diagram using Debezium to tail database transaction logs and publish change events to Kafka, feeding downstream consumers that update search indexes, invalidate caches, load data warehouses, and write audit logs. This template shows how CDC eliminates dual-write problems by capturing changes at the database level without modifying application code. Critical for data synchronization across heterogeneous systems.",,uncategorized/architecture/event-driven-cdc-change-data-capture-architecture +event-driven-dead-letter-queue-architecture,event-driven-dead-letter-queue-architecture,Event-Driven Dead Letter Queue Architecture,architecture,Architecture,incident,compliance,incident;compliance,3,16,3,dead-letter-queue;dlq;retry-policy;message-processing;error-handling;operations-alerting;message-reliability;architecture-diagram,"A dead letter queue architecture diagram with retry policies, exponential backoff, max retry thresholds, DLQ routing for failed messages, operations alerting, and manual reprocessing workflows. This template models the critical error handling pattern for asynchronous messaging systems, ensuring no message is silently lost when processing fails. Essential for building reliable event-driven systems with proper failure recovery mechanisms.",,incident/architecture/event-driven-dead-letter-queue-architecture +cqrs-read-write-separation-architecture,cqrs-read-write-separation-architecture,CQRS Read-Write Separation Architecture,architecture,Architecture,uncategorized,,,4,18,4,cqrs;read-write-separation;command-query;postgresql;redis;elasticsearch;read-model-sync;architecture-diagram,"A CQRS read-write separation architecture diagram with dedicated command and query paths, PostgreSQL for writes, Redis or Elasticsearch for optimized reads, and an event-driven synchronization layer with lag monitoring. This template demonstrates the core CQRS principle of separating read and write models to independently scale and optimize each path. Ideal for applications with asymmetric read/write ratios where query performance is critical.",,uncategorized/architecture/cqrs-read-write-separation-architecture +cqrs-materialized-view-architecture,cqrs-materialized-view-architecture,CQRS Materialized View Architecture,architecture,Architecture,uncategorized,,,4,18,4,materialized-view;cqrs;projectors;read-model;denormalization;query-optimization;event-stream;architecture-diagram,"A CQRS materialized view architecture diagram with multiple projectors building purpose-specific read models: order summaries, customer dashboards, analytics cubes, and search indexes, all fed from a single event stream. This template shows how to create multiple optimized query views from the same write events, each tailored to a specific use case with sub-millisecond read latency. Perfect for systems requiring diverse query patterns from a single data source.",,uncategorized/architecture/cqrs-materialized-view-architecture +cqrs-task-based-ui-architecture,cqrs-task-based-ui-architecture,CQRS Task-Based UI Architecture,architecture,Architecture,uncategorized,,,4,19,4,task-based-ui;cqrs;optimistic-update;websocket;command-pattern;idempotency;reactive-ui;architecture-diagram,"A CQRS task-based UI architecture diagram where the frontend captures user intent as explicit commands, submits them asynchronously with optimistic updates, and receives real-time confirmations via WebSocket when the read model is synchronized. This template models the modern UI pattern that replaces CRUD forms with intent-driven commands, enabling responsive user experiences with eventual consistency. Recommended for teams building reactive frontends on CQRS backends.",,uncategorized/architecture/cqrs-task-based-ui-architecture +serverless-api-backend-architecture,serverless-api-backend-architecture,Serverless API Backend Architecture,architecture,Architecture,mcp,,mcp,3,15,3,serverless;aws-lambda;api-gateway;dynamodb;cloud-architecture;auto-scaling;pay-per-use;architecture-diagram,"A serverless API backend architecture diagram with API Gateway, Lambda authorizer functions, business logic functions, and managed cloud services including DynamoDB, S3, SQS, and SNS for a fully managed, auto-scaling backend. This template models the serverless-first approach where infrastructure management is eliminated entirely, with pay-per-invocation pricing and automatic scaling to zero. Essential for startups and teams building cost-efficient, event-driven API backends.",,mcp/architecture/serverless-api-backend-architecture +serverless-event-processing-architecture,serverless-event-processing-architecture,Serverless Event Processing Architecture,architecture,Architecture,uncategorized,,,4,17,4,serverless;event-processing;step-functions;lambda-triggers;sqs;s3-events;dynamodb-streams;architecture-diagram,"A serverless event processing architecture diagram with S3, DynamoDB Streams, API Gateway, and CloudWatch triggers invoking Lambda functions, orchestrated by Step Functions with fan-out via SQS and dead letter queue error handling. This template shows how to build complex event processing pipelines entirely from managed serverless components, with no servers to provision or manage. Ideal for data processing workflows that need elastic scaling and built-in fault tolerance.",,uncategorized/architecture/serverless-event-processing-architecture +serverless-step-functions-orchestration-architecture,serverless-step-functions-orchestration-architecture,Serverless Step Functions Orchestration Architecture,architecture,Architecture,incident,ai-orchestration,incident;ai-orchestration,4,17,3,step-functions;serverless-orchestration;state-machine;workflow-automation;callback-pattern;compensation;aws;architecture-diagram,"An AWS Step Functions orchestration architecture diagram with state machine workflows including choice states, parallel processing, wait-for-callback patterns, and compensation rollback for failed steps. This template models serverless workflow orchestration where complex multi-step processes are defined as state machines with built-in error handling and retry logic. Critical for teams building reliable serverless workflows that require human approval or long-running processes.",,incident/architecture/serverless-step-functions-orchestration-architecture +serverless-edge-computing-architecture,serverless-edge-computing-architecture,Serverless Edge Computing Architecture,architecture,Architecture,handoff,,handoff,3,15,3,edge-computing;lambda-at-edge;cloudfront;cloudflare;cdn;geo-routing;cache-strategy;architecture-diagram,"A serverless edge computing architecture diagram with CloudFront or Cloudflare edge locations, Lambda@Edge functions for A/B testing and geo-personalization, origin shield request collapsing, and cache-first response strategies. This template visualizes how computation moves to the network edge for ultra-low latency responses, with edge functions modifying requests and responses before they reach the origin. Essential for performance-critical applications serving global audiences.",,handoff/architecture/serverless-edge-computing-architecture +serverless-data-pipeline-architecture,serverless-data-pipeline-architecture,Serverless Data Pipeline Architecture,architecture,Architecture,delivery,,delivery,4,17,4,serverless-data-pipeline;kinesis;glue;athena;s3-data-lake;etl;sagemaker;architecture-diagram,"A serverless data pipeline architecture diagram with Kinesis ingestion, Lambda transformation functions, S3 data lake storage zones (raw and curated), Glue catalog registration, and Athena query engine feeding QuickSight dashboards and SageMaker ML models. This template models a complete serverless ETL pipeline from data ingestion through transformation, cataloging, and analytics without managing any infrastructure. Ideal for data teams building cost-effective analytics platforms.",,delivery/architecture/serverless-data-pipeline-architecture +serverless-multi-cloud-architecture,serverless-multi-cloud-architecture,Serverless Multi-Cloud Architecture,architecture,Architecture,handoff,,handoff,4,18,4,multi-cloud;aws;azure;cloud-failover;dns-routing;data-replication;vendor-independence;architecture-diagram,"A multi-cloud serverless architecture diagram with DNS-based traffic routing between AWS and Azure regions, automatic failover on health check failures, and bi-directional data replication with conflict resolution across cloud providers. This template models the multi-cloud strategy for maximum availability and vendor independence, using serverless services from both AWS (Lambda, DynamoDB) and Azure (Functions, Cosmos DB). Critical for enterprises requiring cloud provider redundancy.",,handoff/architecture/serverless-multi-cloud-architecture +saga-orchestration-pattern-architecture,saga-orchestration-pattern-architecture,Saga Orchestration Pattern Architecture,architecture,Architecture,delivery,ai-orchestration,delivery;ai-orchestration,4,19,5,saga-pattern;orchestration;distributed-transaction;compensation;microservices;rollback;consistency;architecture-diagram,"A saga orchestration architecture diagram with a central orchestrator coordinating multi-step distributed transactions across Order, Inventory, and Payment services, with a dedicated compensation chain for rollback on failure. This template models the orchestration-based saga pattern where a single coordinator manages the transaction lifecycle and triggers compensating actions when any step fails. Essential for architects implementing reliable distributed transactions without two-phase commit.",,delivery/architecture/saga-orchestration-pattern-architecture +saga-choreography-pattern-architecture,saga-choreography-pattern-architecture,Saga Choreography Pattern Architecture,architecture,Architecture,uncategorized,,,4,18,5,saga-choreography;event-driven-saga;decentralized;domain-events;compensation;autonomous-services;distributed-transaction;architecture-diagram,"A saga choreography architecture diagram where Order, Payment, and Inventory services coordinate through domain events without a central orchestrator, with each service publishing and subscribing to events that drive the transaction forward or trigger compensation. This template models the decentralized saga approach where services autonomously react to events, reducing single points of failure at the cost of increased complexity in tracking saga state. Best for teams preferring service autonomy over centralized control.",,uncategorized/architecture/saga-choreography-pattern-architecture +saga-distributed-transaction-architecture,saga-distributed-transaction-architecture,Saga Distributed Transaction Architecture,architecture,Architecture,ai-orchestration,,ai-orchestration,4,17,4,distributed-transaction;two-phase-commit;2pc;transaction-coordinator;consensus;strong-consistency;prepare-commit;architecture-diagram,"A distributed transaction architecture diagram implementing the two-phase commit protocol with a transaction coordinator sending prepare and commit messages to participating services, with global abort on any vote failure. This template visualizes the classic 2PC protocol used when strong consistency is required across multiple services, showing the prepare, vote, and commit/abort phases. Important for understanding distributed consensus trade-offs in microservices architectures.",,ai-orchestration/architecture/saga-distributed-transaction-architecture +saga-travel-booking-architecture,saga-travel-booking-architecture,Saga Travel Booking Architecture,architecture,Architecture,ai-orchestration,,ai-orchestration,4,17,5,saga-pattern;travel-booking;flight-reservation;hotel-booking;compensation;distributed-transaction;orchestration;architecture-diagram,"A travel booking saga architecture diagram orchestrating flight, hotel, and car rental reservations as a single distributed transaction, with automatic compensation to cancel all bookings if any reservation step fails. This template models the classic saga use case where multiple independent services must either all succeed or all roll back, ensuring travelers never end up with partial bookings. Perfect for demonstrating saga patterns with a real-world business scenario.",,ai-orchestration/architecture/saga-travel-booking-architecture +saga-order-fulfillment-architecture,saga-order-fulfillment-architecture,Saga Order Fulfillment Architecture,architecture,Architecture,approval,billing;security,approval;billing;security,4,18,3,order-fulfillment;saga-pattern;e-commerce;payment-authorization;inventory-reservation;compensation-chain;distributed-transaction;architecture-diagram,"An order fulfillment saga architecture diagram with four sequential steps: customer verification, inventory reservation, payment authorization, and shipment creation, with a compensation chain that reverses completed steps on failure. This template models the end-to-end order lifecycle as a saga, showing how each service participates in the transaction and how compensating actions maintain data consistency. Ideal for e-commerce architects designing reliable order processing pipelines.",,approval/architecture/saga-order-fulfillment-architecture +circuit-breaker-resilience-architecture,circuit-breaker-resilience-architecture,Circuit Breaker Resilience Architecture,architecture,Architecture,mcp,,mcp,4,18,3,circuit-breaker;resilience;fault-tolerance;cascading-failure;half-open-state;fallback;state-machine;architecture-diagram,"A circuit breaker resilience architecture diagram showing the complete state machine with closed, open, and half-open states, failure threshold tracking, recovery timer, and fallback response strategies for protecting services from cascading failures. This template visualizes the circuit breaker pattern in detail, including how the breaker transitions between states based on success and failure counts. Essential for building fault-tolerant microservices that degrade gracefully under load.",,mcp/architecture/circuit-breaker-resilience-architecture +bulkhead-isolation-architecture,bulkhead-isolation-architecture,Bulkhead Isolation Architecture,architecture,Architecture,handoff,,handoff,4,18,4,bulkhead-pattern;resource-isolation;thread-pool;backpressure;fault-isolation;resilience;priority-routing;architecture-diagram,"A bulkhead isolation architecture diagram with separate thread pools for critical, standard, and batch workloads, each with independent connection pools, exhaustion detection, and backpressure strategies to prevent one workload from starving others. This template models the bulkhead pattern inspired by ship hull compartments, where resource isolation ensures that a failure or overload in one component cannot cascade to others. Critical for systems requiring guaranteed availability for high-priority operations.",,handoff/architecture/bulkhead-isolation-architecture +retry-with-exponential-backoff-architecture,retry-with-exponential-backoff-architecture,Retry with Exponential Backoff Architecture,architecture,Architecture,uncategorized,,,3,17,3,retry-pattern;exponential-backoff;jitter;transient-failure;resilience;error-handling;thundering-herd;architecture-diagram,"A retry with exponential backoff architecture diagram showing the complete retry policy engine with retryable vs non-retryable error classification, exponential delay calculation with jitter, max retry thresholds, and graceful exhaustion handling. This template models the essential resilience pattern for handling transient failures in distributed systems, preventing thundering herd problems through randomized backoff delays. Foundational for any service-to-service communication in cloud architectures.",,uncategorized/architecture/retry-with-exponential-backoff-architecture +rate-limiter-architecture,rate-limiter-architecture,Rate Limiter Architecture,architecture,Architecture,uncategorized,,,3,17,4,rate-limiter;token-bucket;sliding-window;redis;api-protection;throttling;distributed-rate-limiting;architecture-diagram,"A rate limiter architecture diagram implementing the token bucket algorithm with Redis-backed distributed counters, sliding window logs, API key identification, rate limit headers, and multi-node synchronization for consistent enforcement. This template shows how to protect APIs from abuse and ensure fair usage across clients, with proper HTTP 429 responses and Retry-After headers. Essential for API platform teams building production-grade rate limiting infrastructure.",,uncategorized/architecture/rate-limiter-architecture +health-check-pattern-architecture,health-check-pattern-architecture,Health Check Pattern Architecture,architecture,Architecture,incident,security,incident;security,3,19,4,health-check;load-balancer;self-healing;monitoring;pagerduty;instance-rotation;deep-health-check;architecture-diagram,"A health check pattern architecture diagram with load balancer probes, deep health checks verifying database, cache, disk, and dependency status, automatic instance rotation, and alerting integration with PagerDuty for consecutive failures. This template models the health monitoring infrastructure that enables self-healing systems, where unhealthy instances are automatically removed from rotation and operations teams are alerted. Key for building production-ready services with proper observability.",,incident/architecture/health-check-pattern-architecture +hexagonal-ports-adapters-architecture,hexagonal-ports-adapters-architecture,Hexagonal (Ports and Adapters) Architecture,architecture,Architecture,uncategorized,,,4,16,4,hexagonal-architecture;ports-and-adapters;clean-architecture;dependency-inversion;domain-core;testability;technology-agnostic;architecture-diagram,"A hexagonal architecture diagram showing the clean separation between domain core, inbound adapters (REST, GraphQL, CLI, message consumers), outbound adapters (PostgreSQL, Stripe, email, Redis), and the port interfaces that connect them. This template visualizes the ports and adapters pattern where the domain core has zero dependencies on infrastructure, making it fully testable and technology-agnostic. Foundational for teams adopting clean architecture principles in their codebase.",,uncategorized/architecture/hexagonal-ports-adapters-architecture +clean-architecture-layers,clean-architecture-layers,Clean Architecture Layers,architecture,Architecture,uncategorized,,,3,16,4,clean-architecture;uncle-bob;dependency-rule;layered-architecture;use-cases;entities;interface-adapters;architecture-diagram,"A clean architecture layers diagram showing the four concentric layers: Entities (domain), Use Cases (application), Interface Adapters (controllers, presenters, repositories), and Frameworks & Drivers (web server, database, cloud SDK). This template models Uncle Bob's Clean Architecture with the dependency rule where inner layers never depend on outer layers, ensuring the domain model remains pure and framework-independent. Essential reference for software architects enforcing architectural boundaries.",,uncategorized/architecture/clean-architecture-layers +domain-driven-design-bounded-contexts-architecture,domain-driven-design-bounded-contexts-architecture,Domain-Driven Design Bounded Contexts Architecture,architecture,Architecture,uncategorized,,,4,18,5,domain-driven-design;bounded-context;anti-corruption-layer;context-map;shared-kernel;strategic-ddd;aggregate;architecture-diagram,"A DDD bounded contexts architecture diagram with Order, Customer, Shipping, and Billing contexts connected through an anti-corruption layer, shared kernel, and context map defining integration relationships. This template visualizes the strategic DDD patterns for decomposing complex domains into autonomous bounded contexts that communicate through well-defined integration events. Critical for architects applying Domain-Driven Design to large-scale enterprise systems.",,uncategorized/architecture/domain-driven-design-bounded-contexts-architecture +api-composition-pattern-architecture,api-composition-pattern-architecture,API Composition Pattern Architecture,architecture,Architecture,incident,,incident,3,16,3,api-composition;response-aggregation;fan-out;parallel-requests;timeout-handling;partial-response;microservices;architecture-diagram,"An API composition architecture diagram with a composer service that fans out parallel requests to multiple microservices, collects responses with timeout handling, and merges results into a single unified response with partial fallback support. This template models the API composition pattern used when a single client query requires data from multiple services, avoiding the need for direct service-to-service calls. Useful for teams building aggregation layers in microservices architectures.",,incident/architecture/api-composition-pattern-architecture +outbox-pattern-reliable-messaging-architecture,outbox-pattern-reliable-messaging-architecture,Outbox Pattern for Reliable Messaging Architecture,architecture,Architecture,uncategorized,,,4,18,4,outbox-pattern;transactional-outbox;reliable-messaging;dual-write;exactly-once;debezium;event-publishing;architecture-diagram,"A transactional outbox architecture diagram where domain writes and event publishing happen in the same database transaction, with a relay process polling the outbox table and publishing events to a message broker with guaranteed delivery. This template solves the dual-write problem where updating a database and publishing an event are not atomic, ensuring exactly-once event delivery without distributed transactions. Critical for event-driven architectures requiring reliable message publishing.",,uncategorized/architecture/outbox-pattern-reliable-messaging-architecture +ambassador-pattern-architecture,ambassador-pattern-architecture,Ambassador Pattern Architecture,architecture,Architecture,mcp,,mcp,3,15,3,ambassador-pattern;sidecar-proxy;external-api;retry-logic;circuit-breaker;metrics-collection;cross-cutting-concerns;architecture-diagram,"An ambassador pattern architecture diagram with a local proxy sidecar handling authentication header injection, circuit breaking, retry logic, and metrics collection for outbound requests to external third-party APIs. This template models the ambassador pattern where a helper service running alongside the application offloads cross-cutting concerns for external communication. Useful for teams integrating with unreliable third-party services that need resilience wrappers.",,mcp/architecture/ambassador-pattern-architecture +graphql-federation-architecture,graphql-federation-architecture,GraphQL Federation Architecture,architecture,Architecture,mcp,,mcp,3,15,3,graphql-federation;apollo-gateway;subgraph;schema-stitching;query-plan;federated-api;graphql;architecture-diagram,"A GraphQL federation architecture diagram with an Apollo Gateway building query plans and fanning out to User, Product, and Review subgraphs, each owning its schema and database, with response stitching into a unified GraphQL result. This template models the federated GraphQL approach where multiple teams independently develop and deploy their subgraphs while clients see a single unified API. Ideal for organizations scaling GraphQL across multiple teams and services.",,mcp/architecture/graphql-federation-architecture +zero-trust-security-architecture,zero-trust-security-architecture,Zero Trust Security Architecture,architecture,Architecture,security,,security,4,19,4,zero-trust;security-architecture;mfa;micro-segmentation;mtls;least-privilege;continuous-verification;architecture-diagram,"A zero trust security architecture diagram with device posture checks, MFA identity verification, risk-based policy decisions, short-lived JWT tokens, micro-segmentation, mTLS encryption, least-privilege access enforcement, and continuous monitoring. This template models the 'never trust, always verify' security paradigm where every request is authenticated and authorized regardless of network location. Essential for security architects implementing modern zero-trust frameworks in cloud-native environments.",,security/architecture/zero-trust-security-architecture +multi-tenant-saas-architecture,multi-tenant-saas-architecture,Multi-Tenant SaaS Architecture,architecture,Architecture,security,delivery,security;delivery,4,17,4,multi-tenant;saas-architecture;tenant-isolation;row-level-security;shared-infrastructure;enterprise-tier;data-isolation;architecture-diagram,"A multi-tenant SaaS architecture diagram with tenant identification, tier-based routing (shared vs dedicated pools), row-level security, per-tenant encryption keys, and isolated backup strategies for standard and enterprise isolation models. This template models the architecture decisions for building SaaS platforms that serve multiple customers from shared infrastructure while maintaining strict data isolation. Critical for SaaS architects balancing cost efficiency with enterprise security requirements.",,security/architecture/multi-tenant-saas-architecture +kubernetes-container-orchestration-architecture,kubernetes-container-orchestration-architecture,Kubernetes Container Orchestration Architecture,architecture,Architecture,ai-orchestration,,ai-orchestration,4,18,4,kubernetes;container-orchestration;k8s;control-plane;worker-node;ingress;persistent-storage;architecture-diagram,"A Kubernetes container orchestration architecture diagram showing the control plane (API Server, etcd, Scheduler, Controller Manager), worker nodes (Kubelet, container runtime, kube-proxy, pods), networking layer (Ingress, Network Policy, Service Mesh), and persistent storage with CSI drivers. This template provides a comprehensive view of the Kubernetes architecture stack from control plane to storage layer. Foundational reference for DevOps engineers and platform teams managing Kubernetes clusters.",,ai-orchestration/architecture/kubernetes-container-orchestration-architecture +data-mesh-architecture,data-mesh-architecture,Data Mesh Architecture,architecture,Architecture,uncategorized,,,4,17,4,data-mesh;domain-ownership;data-product;self-serve-data;federated-governance;data-platform;data-architecture;architecture-diagram,"A data mesh architecture diagram with domain-oriented data ownership across Sales, Marketing, and Finance domains, each exposing self-serve data products through APIs with quality SLAs, governed by a federated data platform with a shared catalog and cross-domain query engine. This template models the paradigm shift from centralized data teams to domain-owned data products, applying microservices principles to data architecture. Essential for organizations scaling data operations beyond centralized data warehouse bottlenecks.",,uncategorized/architecture/data-mesh-architecture +cell-based-architecture,cell-based-architecture,Cell-Based Architecture,architecture,Architecture,handoff,,handoff,4,20,4,cell-based-architecture;blast-radius;geographic-routing;fault-isolation;independent-cells;cross-cell-replication;hyperscale;architecture-diagram,"A cell-based architecture diagram with geographic routing to independent, self-contained cells (US-East, EU-West), each with its own gateway, compute, database, cache, and message queue, plus shared services for cross-cell replication and global configuration. This template models the cell architecture pattern used by hyperscale systems to achieve blast radius isolation, where failures in one cell cannot affect users in another. Key for architects designing systems that require extreme availability and fault isolation.",,handoff/architecture/cell-based-architecture +observability-three-pillars-architecture,observability-three-pillars-architecture,Observability Three Pillars Architecture,architecture,Architecture,uncategorized,,,4,17,4,observability;three-pillars;opentelemetry;prometheus;jaeger;loki;grafana;slo-sli;architecture-diagram,"An observability architecture diagram implementing the three pillars (metrics, traces, logs) with OpenTelemetry SDK instrumentation, OTLP collector pipeline, Prometheus, Jaeger, and Loki backends, Grafana dashboards, SLO/SLI tracking, and PagerDuty alerting integration. This template provides a complete observability stack reference showing how telemetry data flows from application instrumentation through collection, storage, visualization, and incident response. Essential for SRE teams building production monitoring infrastructure.",,uncategorized/architecture/observability-three-pillars-architecture +gitops-deployment-architecture,gitops-deployment-architecture,GitOps Deployment Architecture,architecture,Architecture,delivery,,delivery,4,19,4,gitops;argocd;flux;kubernetes-deployment;declarative-infrastructure;drift-detection;rolling-update;architecture-diagram,"A GitOps deployment architecture diagram with developer Git workflow, CI/CD pipeline building and pushing container images, ArgoCD or Flux detecting Git manifest changes, drift detection, automatic cluster synchronization, and rolling update deployment to Kubernetes. This template models the GitOps paradigm where Git is the single source of truth for both application code and infrastructure state, enabling declarative, auditable, and reproducible deployments. Critical for teams adopting GitOps practices for Kubernetes deployments.",,delivery/architecture/gitops-deployment-architecture +ai-native-single-agent-architecture,ai-native-single-agent-architecture,AI-Native Single Agent Architecture,architecture,Architecture,agentic,ai-orchestration;mcp,agentic;ai-orchestration;mcp,2,11,3,ai-native;single-agent;agentic-ai;mcp;architecture-diagram,"A single-agent AI architecture where one agent handles everything: parsing requests, reasoning, calling tools via MCP, and generating responses. This is the default architecture for prototypes and simple automations—easy to debug but hits context-window limits quickly and is hard to parallelize. Ideal for MVPs and solo builders shipping fast.",,agentic/architecture/ai-native-single-agent-architecture +ai-native-sequential-pipeline-architecture,ai-native-sequential-pipeline-architecture,AI-Native Sequential Pipeline Architecture,architecture,Architecture,delivery,agentic;ai-orchestration,delivery;agentic;ai-orchestration,2,7,2,ai-native;sequential-pipeline;agentic-ai;llm-microservices;architecture-diagram,"A sequential pipeline architecture chaining multiple agents in a fixed order (parse → enrich → analyze → format), which is a common 'LLM microservices' setup when each step can be isolated. This structure is often used in document processing and ETL-like workflows because each step is testable and predictable.",,delivery/architecture/ai-native-sequential-pipeline-architecture +ai-native-orchestrator-worker-architecture,ai-native-orchestrator-worker-architecture,AI-Native Orchestrator-Worker Architecture,architecture,Architecture,agentic,ai-orchestration,agentic;ai-orchestration,3,14,4,ai-native;orchestrator-worker;agentic-ai;langgraph;multi-agent;architecture-diagram,"An orchestrator-worker architecture where an orchestrator agent breaks a goal into subtasks, dispatches to specialized workers, then synthesizes a final response. This is the most common 'agent orchestration' architecture—powerful but the orchestrator can become a bottleneck as the number of workers grows. Frameworks like LangGraph focus on explicit routing/state to manage this.",,agentic/architecture/ai-native-orchestrator-worker-architecture +ai-native-hierarchical-architecture,ai-native-hierarchical-architecture,AI-Native Hierarchical Architecture,architecture,Architecture,agentic,ai-orchestration,agentic;ai-orchestration,4,16,4,ai-native;hierarchical;agentic-ai;enterprise;multi-agent;architecture-diagram,"A hierarchical multi-agent architecture that scales orchestration by stacking supervisors and team leads (a tree structure), which mirrors enterprise org structures and helps partition context. This is the 'enterprise-grade agentic AI architecture' when a single orchestrator cannot manage all workers directly. Ideal for large enterprises and multi-domain workflows.",,agentic/architecture/ai-native-hierarchical-architecture +ai-native-parallel-fan-out-architecture,ai-native-parallel-fan-out-architecture,AI-Native Parallel Fan-Out Architecture,architecture,Architecture,delivery,agentic;ai-orchestration,delivery;agentic;ai-orchestration,3,11,2,ai-native;parallel-fan-out;agentic-ai;map-reduce;ci-cd;architecture-diagram,"A parallel fan-out architecture that runs multiple agents simultaneously on independent checks (style, security, performance) and then merges results. This is a standard multi-agent design approach for throughput, mapping cleanly to CI/CD, incident response, and research. Fan-in reconciliation becomes the subtle part.",,delivery/architecture/ai-native-parallel-fan-out-architecture +ai-native-event-driven-kafka-architecture,ai-native-event-driven-kafka-architecture,AI-Native Event-Driven Kafka Architecture,architecture,Architecture,agentic,ai-orchestration;mcp,agentic;ai-orchestration;mcp,3,12,5,ai-native;event-driven;agentic-ai;kafka;pub-sub;agent-mesh;architecture-diagram,"An event-driven agentic AI architecture that replaces the central orchestrator with Kafka/PubSub topics: agents subscribe, react, and publish new events. This aligns multi-agent systems with proven microservices choreography and is ideal for real-time, high-throughput systems and 'agent mesh' setups.",,agentic/architecture/ai-native-event-driven-kafka-architecture +ai-native-generator-critic-architecture,ai-native-generator-critic-architecture,AI-Native Generator-Critic Architecture,architecture,Architecture,agentic,ai-orchestration,agentic;ai-orchestration,3,9,3,ai-native;generator-critic;agentic-ai;tournament-mode;multi-agent;architecture-diagram,"A competitive / generator-critic architecture where multiple generators produce independent answers, then an evaluator agent scores and selects the best output. This approach improves quality and reduces single-model brittleness. It's costlier (multiple LLM calls) but pays off when correctness or creativity matters more than latency.",,agentic/architecture/ai-native-generator-critic-architecture +event-driven-notification-hub-architecture,event-driven-notification-hub-architecture,Event-Driven Notification Hub Architecture,architecture,Architecture,uncategorized,,,4,20,3,notification-hub;multi-channel;event-driven;sendgrid;firebase-cloud-messaging;twilio;delivery-tracking;architecture-diagram,"An event-driven notification hub architecture diagram with multi-source event ingestion, template-based message rendering, user preference routing across email (SendGrid/SES), push (FCM), SMS (Twilio), and Slack channels, with delivery tracking and retry mechanisms. This template models a centralized notification system that decouples business services from delivery infrastructure, supporting multi-channel communication with user-controlled preferences. Ideal for platform teams building scalable notification infrastructure.",,uncategorized/architecture/event-driven-notification-hub-architecture +agentic-supervisor-worker,agentic-supervisor-worker,Agentic Supervisor-Worker Architecture,architecture,Architecture,agentic,,agentic,3,10,4,agentic;supervisor-worker;multi-agent;orchestrator;architecture-diagram;ai-team,"A supervisor-worker multi-agent architecture where an orchestrator agent receives a high-level goal, breaks it into subtasks, delegates each to specialist worker agents (researcher, writer, QA), monitors execution, handles failures, and synthesizes results. The orchestrator manages but does not execute tasks itself.",,agentic/architecture/agentic-supervisor-worker +agentic-sequential-pipeline,agentic-sequential-pipeline,Agentic Sequential Pipeline Architecture,architecture,Architecture,delivery,agentic;ai-orchestration,delivery;agentic;ai-orchestration,2,5,5,agentic;sequential-pipeline;multi-agent;assembly-line;architecture-diagram;ai-team,"A sequential pipeline multi-agent architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. No central orchestrator — the flow is deterministic like an assembly line.",,delivery/architecture/agentic-sequential-pipeline +agentic-swarm,agentic-swarm,Agentic Swarm Architecture,architecture,Architecture,agentic,,agentic,3,6,5,agentic;swarm;multi-agent;parallel;aggregator;architecture-diagram;ai-team,"A swarm multi-agent architecture where multiple agents work on the same or related tasks simultaneously, with no central coordinator. Their outputs are then aggregated, voted on, or merged by a dedicated aggregator node. Agents may compete — the best output wins.",,agentic/architecture/agentic-swarm +agentic-hierarchical,agentic-hierarchical,Agentic Hierarchical Architecture,architecture,Architecture,agentic,,agentic,4,8,7,agentic;hierarchical;multi-agent;enterprise;architecture-diagram;ai-team,"A hierarchical multi-agent architecture with multi-level organizational structure. A top-level executive agent manages mid-level team lead agents, who each manage their own pool of specialist workers. Teams within teams — the hierarchy maps to domain separation.",,agentic/architecture/agentic-hierarchical +agentic-team-of-rivals,agentic-team-of-rivals,Agentic Team of Rivals Architecture,architecture,Architecture,agentic,,agentic,3,5,3,agentic;team-of-rivals;multi-agent;critic;veto;architecture-diagram;ai-team,The most architecturally sophisticated multi-agent pattern. Agents are assigned not just roles but opposing incentives. A Planner is optimistic about goal completion. A Critic is constitutionally skeptical and holds veto authority. Errors get caught through adversarial pressure rather than trusting a single model's self-assessment.,,agentic/architecture/agentic-team-of-rivals +ai-orchestration-single-agent,ai-orchestration-single-agent,AI Orchestration - Single Agent (Monolith),architecture,Architecture,ai-orchestration,mcp,ai-orchestration;mcp,2,12,3,ai-native;single-agent;monolith;mcp;architecture-diagram;orchestration,"The simplest AI-native architecture — a single agent that receives user input, reasons, plans, decides on tool calls, processes results, and generates responses. Direct MCP connection over stdio or HTTP. Best for MVPs and when low latency matters.",,ai-orchestration/architecture/ai-orchestration-single-agent +ai-orchestration-sequential-pipeline,ai-orchestration-sequential-pipeline,AI Orchestration - Sequential Pipeline,architecture,Architecture,delivery,ai-orchestration,delivery;ai-orchestration,2,5,2,ai-native;sequential-pipeline;assembly-line;architecture-diagram;orchestration,"An assembly-line architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. Best for tasks with clear sequential dependencies — document processing, content production pipelines, compliance workflows.",,delivery/architecture/ai-orchestration-sequential-pipeline +ai-orchestration-orchestrator-worker,ai-orchestration-orchestrator-worker,AI Orchestration - Orchestrator-Worker,architecture,Architecture,agentic,ai-orchestration,agentic;ai-orchestration,3,15,5,ai-native;orchestrator-worker;conductor;multi-agent;architecture-diagram;orchestration,"A conductor-style architecture where one orchestrator agent receives a complex task, breaks it into subtasks, dispatches each to specialist worker agents (research, code, review), collects results, and synthesizes the final answer. Best for complex multi-step tasks with dynamic decomposition.",,agentic/architecture/ai-orchestration-orchestrator-worker +ai-orchestration-hierarchical,ai-orchestration-hierarchical,AI Orchestration - Hierarchical (Org Chart),architecture,Architecture,agentic,ai-orchestration,agentic;ai-orchestration,4,17,5,ai-native;hierarchical;org-chart;enterprise;multi-agent;architecture-diagram;orchestration,"An org-chart architecture with multi-level structure. A top-level supervisor manages team leads, who each manage their own pool of specialist workers. Teams within teams. Best for enterprise-scale automation with 10+ specialized agents spanning multiple domains.",,agentic/architecture/ai-orchestration-hierarchical +ai-orchestration-parallel-fan-out,ai-orchestration-parallel-fan-out,AI Orchestration - Parallel Fan-Out (Map-Reduce),architecture,Architecture,agentic,ai-orchestration,agentic;ai-orchestration,3,9,3,ai-native;parallel-fan-out;map-reduce;coordinator;multi-agent;architecture-diagram;orchestration,"A map-reduce style architecture where a coordinator fans out tasks to multiple parallel worker agents (style check, security audit, performance analysis), gathers all results, and makes an aggregate decision. Best for PR reviews, code reviews, and multi-dimensional analysis.",,agentic/architecture/ai-orchestration-parallel-fan-out +ai-orchestration-event-driven-mesh,ai-orchestration-event-driven-mesh,AI Orchestration - Event-Driven Mesh (Kafka-First),architecture,Architecture,ai-orchestration,mcp,ai-orchestration;mcp,3,13,5,ai-native;event-driven;kafka;agent-mesh;pub-sub;architecture-diagram;orchestration,"An event-driven agent mesh architecture using a Kafka-style event broker. Multiple agents subscribe to topics (orders, alerts, analytics), process events independently, and publish results back to the bus. Best for real-time event processing and decoupled service architectures.",,ai-orchestration/architecture/ai-orchestration-event-driven-mesh +ai-orchestration-competitive-generator-critic,ai-orchestration-competitive-generator-critic,AI Orchestration - Competitive Generator-Critic,architecture,Architecture,agentic,ai-orchestration,agentic;ai-orchestration,3,10,3,ai-native;competitive;generator-critic;tournament;multi-agent;architecture-diagram;orchestration,"A tournament-mode architecture where multiple generator agents produce independent outputs in parallel, then an evaluator agent scores and selects the best. Quality threshold checking with refinement loops. Best when correctness or creativity matters more than latency.",,agentic/architecture/ai-orchestration-competitive-generator-critic +mcp-direct-connect,mcp-direct-connect,MCP Direct Connect Architecture,architecture,DevOps,mcp,,mcp,1,6,2,mcp;direct-connect;stdio;http;architecture-diagram;production-grade,"The simplest MCP pattern — direct connection between host application and MCP server over stdio or HTTP. No extra hops, lowest latency, easiest debugging. Perfect for MVPs, hackathons, and single-team setups where security governance is not yet a concern.",,mcp/devops/mcp-direct-connect +mcp-gateway-proxy,mcp-gateway-proxy,MCP Gateway Proxy Architecture,architecture,DevOps,security,compliance;mcp,security;compliance;mcp,3,7,3,mcp;gateway;proxy;oauth;rate-limiting;audit;architecture-diagram;production-grade,"An API gateway pattern that sits between agents and MCP servers to handle authentication, rate limits, and auditing. The gateway enforces OAuth 2.0, SAML, SSO, tool-level rate limiting, and team-based quotas. Essential for multi-team or multi-tenant MCP deployments.",,security/devops/mcp-gateway-proxy +mcp-tool-router,mcp-tool-router,MCP Tool Router Architecture,architecture,DevOps,handoff,mcp,handoff;mcp,3,8,4,mcp;tool-router;semantic-routing;embeddings;token-optimization;architecture-diagram;production-grade,A routing pattern that puts a semantic router in front of MCP tools so the LLM only sees the subset it needs. Uses vector embeddings and cosine similarity to match user intent to tools dynamically. Achieves up to 96% reduction in input tokens when dealing with large tool catalogs.,,handoff/devops/mcp-tool-router +mcp-agent-mesh,mcp-agent-mesh,MCP Agent Mesh Architecture,architecture,DevOps,agentic,mcp,agentic;mcp,4,10,4,mcp;agent-mesh;shared-context;multi-agent;broker;architecture-diagram;production-grade,"A multi-agent mesh pattern where agents communicate through a shared context broker backed by MCP. Enables coordinated tool access and state synchronization across multiple specialized agents (planner, coder, reviewer, operator). Supports both orchestrated and choreographed interaction patterns.",,agentic/devops/mcp-agent-mesh +mcp-circuit-breaker,mcp-circuit-breaker,MCP Circuit Breaker Architecture,architecture,DevOps,mcp,,mcp,3,9,3,mcp;circuit-breaker;resilience;fault-tolerance;health-check;architecture-diagram;production-grade,"A resilience pattern that wraps MCP calls with health-aware gates using three states: Closed (normal), Open (failures detected, fast-fail), and Half-Open (testing recovery). Prevents cascading failures when tools become unresponsive. Essential for production-grade reliability.",,mcp/devops/mcp-circuit-breaker +mcp-context-proxy,mcp-context-proxy,MCP Context Proxy Architecture,architecture,DevOps,mcp,,mcp,3,7,3,mcp;context-proxy;caching;compression;token-optimization;architecture-diagram;production-grade,"A caching and compression layer that sits between agents and MCP servers, intercepting redundant context requests before they hit the wire. Uses TTL-based cache invalidation, Brotli compression, and semantic caching. Can achieve up to 95%+ token reduction and significantly lower LLM bills.",,mcp/devops/mcp-context-proxy +context-session-memory,context-session-memory,Context Management - Session Memory,architecture,Architecture,context-management,,context-management,2,9,3,context-management;session-memory;short-term;memory;architecture-diagram,"Short-term context pattern where the channel sends new messages plus recent history. The agent runtime merges that with local session state, assembles the prompt, and persists the response back into history. Simple but cost and latency grow with history length.",,context-management/architecture/context-session-memory +context-rolling-summary-memory,context-rolling-summary-memory,Context Management - Rolling Summary Memory,architecture,Architecture,context-management,,context-management,3,8,4,context-management;rolling-summary;compression;memory;architecture-diagram,"Compressed history pattern that keeps full history for a while, then when a threshold is hit, summarizes the last chunk and replaces detailed turns with a shorter summary message. Dramatically reduces prompt size on long-running chats while maintaining gist continuity.",,context-management/architecture/context-rolling-summary-memory +context-profile-memory,context-profile-memory,Context Management - Profile Memory,architecture,Architecture,context-management,,context-management,2,7,3,context-management;profile-memory;identity;user-profile;architecture-diagram,"Identity-style memory pattern where profile data is loaded at session start. Each prompt combines system persona, user profile, and current message. New facts can be written back to profile memory. Small predictable overhead with big UX lift — the agent remembers your name, stack, tone, and constraints.",,context-management/architecture/context-profile-memory +context-semantic-memory,context-semantic-memory,Context Management - Semantic Memory,architecture,Architecture,context-management,,context-management,3,9,4,context-management;semantic-memory;vector-db;embeddings;rag;architecture-diagram,"Vector-based memory pattern where text is chunked, embedded, and stored in a vector database. On query, the question is embedded, a vector search is run, candidates are reranked, and top results are injected into the prompt. Where the agent feels like it remembers everything without hallucinating.",,context-management/architecture/context-semantic-memory +context-episodic-memory,context-episodic-memory,Context Management - Episodic Memory,architecture,Architecture,context-management,,context-management,3,11,4,context-management;episodic-memory;learning;experience;architecture-diagram,"Learning-from-experience pattern where every task run becomes an episode with input, actions, and outcome. Before tackling a new task, the agent fetches similar episodes and uses them as hints. Over time, the agent feels like it's learning instead of repeating the same failed plans.",,context-management/architecture/context-episodic-memory +context-hybrid-retrieval-memory,context-hybrid-retrieval-memory,Context Management - Hybrid Retrieval Memory,architecture,Architecture,context-management,,context-management,4,11,5,context-management;hybrid-retrieval;semantic;keyword;recency;architecture-diagram,"Multi-modal retrieval pattern combining semantic search, exact/keyword search, and recency search in parallel. Results are merged and reranked into a single context set. Much higher recall because the agent can find both fuzzy references and exact entities. Essential for comprehensive knowledge retrieval.",,context-management/architecture/context-hybrid-retrieval-memory +context-shared-memory,context-shared-memory,Context Management - Shared Memory,architecture,Architecture,agentic,context-management,agentic;context-management,3,9,4,context-management;shared-memory;multi-agent;orchestrator;architecture-diagram,"Multi-agent coordination pattern where an orchestrator breaks work into subtasks, specialist agents pull from and push to a shared state store, and the orchestrator composes the final answer from that shared state. Multi-agent setups feel coherent instead of each assistant having its own inconsistent memory.",,agentic/architecture/context-shared-memory diff --git a/offboarding/business-operations/account-deletion-workflow/README.md b/offboarding/business-operations/account-deletion-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5442404cfd9f495c68e3d6aa784324e1136b8feb --- /dev/null +++ b/offboarding/business-operations/account-deletion-workflow/README.md @@ -0,0 +1,19 @@ +# Account Deletion Workflow + +Account deletion workflow with cancellation reason capture, retention offer, subscription termination, data cleanup, and confirmation email. + +**Template ID:** `account-deletion-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** offboarding +**Secondary use cases:** billing +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [account-deletion, user-offboarding, data-cleanup, subscription-cancel, retention-offer, exit-survey] +**Source path:** `business-operations/account-deletion` +**Repo path:** `offboarding/business-operations/account-deletion-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/offboarding/business-operations/account-deletion-workflow/metadata.json b/offboarding/business-operations/account-deletion-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f190251cf9f418b6f44d66f9a48c1ffd1d874199 --- /dev/null +++ b/offboarding/business-operations/account-deletion-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "account-deletion-workflow", + "workflow_id": "account-deletion", + "title": "Account Deletion Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "offboarding", + "secondary_use_cases": [ + "billing" + ], + "use_cases": [ + "offboarding", + "billing" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "account-deletion", + "user-offboarding", + "data-cleanup", + "subscription-cancel", + "retention-offer", + "exit-survey" + ], + "description": "Account deletion workflow with cancellation reason capture, retention offer, subscription termination, data cleanup, and confirmation email.", + "source_path": "business-operations/account-deletion", + "repo_path": "offboarding/business-operations/account-deletion-workflow" +} diff --git a/offboarding/business-operations/account-deletion-workflow/workflow.fz b/offboarding/business-operations/account-deletion-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..68b67b608bd4d2e9e2a5e39ea549efe563ab276c --- /dev/null +++ b/offboarding/business-operations/account-deletion-workflow/workflow.fz @@ -0,0 +1,40 @@ +User { # User +n1: circle label:"Start" +n2: rectangle label:"Request account deletion" +n3: rectangle label:"Confirm via email link" +n4: rectangle label:"Download data export" +n5: rectangle label:"Receive deletion confirmation" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> App.n7.handle(top) [label="Submit request"] +n3.handle(bottom) -> App.n10.handle(top) [label="Confirmed"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +} +App { # Application +n7: rectangle label:"Validate user identity" +n8: diamond label:"Active subscriptions?" +n9: rectangle label:"Send confirmation email" +n10: rectangle label:"Queue deletion job" +n11: rectangle label:"Generate data export" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="No"] +n8.handle(bottom) -> Billing.n15.handle(top) [label="Yes - Cancel first"] +n9.handle(top) -> User.n3.handle(bottom) [label="Email sent"] +n10.handle(bottom) -> Backend.n12.handle(top) [label="Process"] +n11.handle(top) -> User.n4.handle(bottom) [label="Ready"] +} +Backend { # Backend +n12: rectangle label:"Anonymize user records" +n13: rectangle label:"Delete personal data" +n14: rectangle label:"Purge from backups" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(top) -> App.n11.handle(bottom) [label="Complete"] +} +Billing { # Billing +n15: rectangle label:"Cancel active subscriptions" +n16: rectangle label:"Process final invoice" +n15.handle(right) -> n16.handle(left) +n16.handle(top) -> App.n9.handle(bottom) [label="Cleared"] +} \ No newline at end of file diff --git a/onboarding/business-operations/ab-test-setup-workflow/README.md b/onboarding/business-operations/ab-test-setup-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..50b4f78a1cbb88f27febc7318fe438c8e39b4f38 --- /dev/null +++ b/onboarding/business-operations/ab-test-setup-workflow/README.md @@ -0,0 +1,19 @@ +# Ab Test Setup Workflow + +A/B test setup workflow with hypothesis definition, variant creation, traffic allocation, statistical analysis, and winner deployment. + +**Template ID:** `ab-test-setup-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** onboarding +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [ab-testing, experimentation, split-testing, statistical-significance, conversion-optimization, optimizely] +**Source path:** `business-operations/ab-test-setup` +**Repo path:** `onboarding/business-operations/ab-test-setup-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/onboarding/business-operations/ab-test-setup-workflow/metadata.json b/onboarding/business-operations/ab-test-setup-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..821b397ae7b71a6b72f9327d493b55376f68cbf8 --- /dev/null +++ b/onboarding/business-operations/ab-test-setup-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "ab-test-setup-workflow", + "workflow_id": "ab-test-setup", + "title": "Ab Test Setup Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "onboarding", + "secondary_use_cases": [], + "use_cases": [ + "onboarding" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "ab-testing", + "experimentation", + "split-testing", + "statistical-significance", + "conversion-optimization", + "optimizely" + ], + "description": "A/B test setup workflow with hypothesis definition, variant creation, traffic allocation, statistical analysis, and winner deployment.", + "source_path": "business-operations/ab-test-setup", + "repo_path": "onboarding/business-operations/ab-test-setup-workflow" +} diff --git a/onboarding/business-operations/ab-test-setup-workflow/workflow.fz b/onboarding/business-operations/ab-test-setup-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..30c82ece4fddecdbd549fc0aa173f060a3d4b8b9 --- /dev/null +++ b/onboarding/business-operations/ab-test-setup-workflow/workflow.fz @@ -0,0 +1,40 @@ +ProductManager { # Product Manager +n1: circle label:"Start" +n2: rectangle label:"Define test hypothesis" +n3: rectangle label:"Select target audience segment" +n4: rectangle label:"Review test results" +n5: diamond label:"Statistically significant?" +n6: rectangle label:"Document findings" +n7: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Engineering.n8.handle(top) [label="Request setup"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) [label="Yes"] +n5.handle(bottom) -> Analytics.n14.handle(top) [label="No - Extend test"] +n6.handle(right) -> n7.handle(left) +} +Engineering { # Engineering +n8: rectangle label:"Create feature flags" +n9: rectangle label:"Implement variant A" +n10: rectangle label:"Implement variant B" +n11: diamond label:"QA passed?" +n12: rectangle label:"Deploy to production" +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n9.handle(bottom) [label="No - Fix bugs"] +n12.handle(bottom) -> Analytics.n13.handle(top) [label="Start tracking"] +} +Analytics { # Analytics +n13: rectangle label:"Configure tracking events" +n14: rectangle label:"Monitor conversion metrics" +n15: diamond label:"Enough sample size?" +n16: rectangle label:"Generate statistical report" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n14.handle(bottom) [label="No - Continue"] +n16.handle(top) -> ProductManager.n4.handle(bottom) [label="Results ready"] +} \ No newline at end of file diff --git a/onboarding/business-operations/two-factor-setup-workflow/README.md b/onboarding/business-operations/two-factor-setup-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6a9033f32eeff9ad59edf54cc35baa6a3767db5f --- /dev/null +++ b/onboarding/business-operations/two-factor-setup-workflow/README.md @@ -0,0 +1,19 @@ +# Two Factor Setup Workflow + +Two-factor authentication setup workflow with method selection (TOTP/SMS), QR code generation, backup codes, and verification confirmation. + +**Template ID:** `two-factor-setup-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** onboarding +**Secondary use cases:** security +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [two-factor-auth, mfa, totp, authenticator-app, security, account-protection] +**Source path:** `business-operations/two-factor-setup` +**Repo path:** `onboarding/business-operations/two-factor-setup-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/onboarding/business-operations/two-factor-setup-workflow/metadata.json b/onboarding/business-operations/two-factor-setup-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4b3ef58727293fc90831578c8e6b2a9c4f107aad --- /dev/null +++ b/onboarding/business-operations/two-factor-setup-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "two-factor-setup-workflow", + "workflow_id": "two-factor-setup", + "title": "Two Factor Setup Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "onboarding", + "secondary_use_cases": [ + "security" + ], + "use_cases": [ + "onboarding", + "security" + ], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "two-factor-auth", + "mfa", + "totp", + "authenticator-app", + "security", + "account-protection" + ], + "description": "Two-factor authentication setup workflow with method selection (TOTP/SMS), QR code generation, backup codes, and verification confirmation.", + "source_path": "business-operations/two-factor-setup", + "repo_path": "onboarding/business-operations/two-factor-setup-workflow" +} diff --git a/onboarding/business-operations/two-factor-setup-workflow/workflow.fz b/onboarding/business-operations/two-factor-setup-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9b516f242a9f065d2072fab2adeab38a6ed1a5b0 --- /dev/null +++ b/onboarding/business-operations/two-factor-setup-workflow/workflow.fz @@ -0,0 +1,43 @@ +User { # User +n1: circle label:"Start" +n2: rectangle label:"Navigate to security settings" +n3: rectangle label:"Select 2FA method" +n4: rectangle label:"Scan QR code with app" +n5: rectangle label:"Enter verification code" +n6: rectangle label:"Save backup codes" +n7: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> AuthService.n8.handle(top) [label="Enable 2FA"] +n3.handle(bottom) -> AuthService.n10.handle(top) [label="TOTP selected"] +n4.handle(bottom) -> AuthService.n13.handle(top) [label="Submit code"] +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +} +AuthService { # Auth Service +n8: rectangle label:"Check current 2FA status" +n9: rectangle label:"Present method options" +n10: rectangle label:"Generate TOTP secret" +n11: rectangle label:"Create QR code" +n12: rectangle label:"Store pending secret" +n13: diamond label:"Code valid?" +n14: rectangle label:"Activate 2FA" +n15: rectangle label:"Show error message" +n8.handle(right) -> n9.handle(left) +n9.handle(top) -> User.n3.handle(bottom) [label="Choose method"] +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> User.n4.handle(bottom) [label="Display QR"] +n13.handle(right) -> n14.handle(left) [label="Yes"] +n13.handle(bottom) -> n15.handle(top) [label="No"] +n14.handle(bottom) -> BackupCodes.n16.handle(top) [label="Generate backups"] +n15.handle(top) -> User.n4.handle(bottom) [label="Try again"] +loop [retry until valid] n13 n15 +} +BackupCodes { # Backup Codes +n16: rectangle label:"Generate 10 backup codes" +n17: rectangle label:"Hash and store codes" +n18: rectangle label:"Display codes to user" +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(top) -> User.n5.handle(bottom) [label="Save these"] +} \ No newline at end of file diff --git a/onboarding/business-operations/user-onboarding-workflow/README.md b/onboarding/business-operations/user-onboarding-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..75e9432994c67e8fab8653780553b94838fa47e2 --- /dev/null +++ b/onboarding/business-operations/user-onboarding-workflow/README.md @@ -0,0 +1,19 @@ +# User Onboarding Workflow + +New user onboarding workflow with welcome email, profile setup, product tour, first action prompt, and activation milestone tracking. + +**Template ID:** `user-onboarding-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** onboarding +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [user-onboarding, activation, product-tour, welcome-email, first-time-user, time-to-value] +**Source path:** `business-operations/user-onboarding` +**Repo path:** `onboarding/business-operations/user-onboarding-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/onboarding/business-operations/user-onboarding-workflow/metadata.json b/onboarding/business-operations/user-onboarding-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c906c59e0d60fde5444ad3f11818d4a759f1f5bd --- /dev/null +++ b/onboarding/business-operations/user-onboarding-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "user-onboarding-workflow", + "workflow_id": "user-onboarding", + "title": "User Onboarding Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "onboarding", + "secondary_use_cases": [], + "use_cases": [ + "onboarding" + ], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "user-onboarding", + "activation", + "product-tour", + "welcome-email", + "first-time-user", + "time-to-value" + ], + "description": "New user onboarding workflow with welcome email, profile setup, product tour, first action prompt, and activation milestone tracking.", + "source_path": "business-operations/user-onboarding", + "repo_path": "onboarding/business-operations/user-onboarding-workflow" +} diff --git a/onboarding/business-operations/user-onboarding-workflow/workflow.fz b/onboarding/business-operations/user-onboarding-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..fed505da4c7f896bf32831c61dc4431b2984becf --- /dev/null +++ b/onboarding/business-operations/user-onboarding-workflow/workflow.fz @@ -0,0 +1,20 @@ +customer { # Customer + n1: circle label:"Start User Onboarding" + n3: rectangle label:"Review User Onboarding details" + n5: rectangle label:"Update records for User Onboarding" + n7: circle label:"End User Onboarding" + + n1.handle(bottom) -> agent.n2.handle(top) + n3.handle(bottom) -> agent.n4.handle(top) [label="Processed"] + n5.handle(bottom) -> agent.n6.handle(top) +} +agent { # Agent + n2: rectangle label:"Receive User Onboarding request" + n4: rectangle label:"Make User Onboarding decision" + n6: diamond label:"Continue User Onboarding process" + + n2.handle(bottom) -> customer.n3.handle(top) + n4.handle(bottom) -> customer.n5.handle(top) + n6.handle(bottom) -> customer.n7.handle(top) [label="Success"] + n6.handle(right) -> customer.n5.handle(right) [label="Retry/Rejected"] +} \ No newline at end of file diff --git a/onboarding/business-operations/webinar-registration-workflow/README.md b/onboarding/business-operations/webinar-registration-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e405679468e652c599b173ed0f0b70525768f6a4 --- /dev/null +++ b/onboarding/business-operations/webinar-registration-workflow/README.md @@ -0,0 +1,19 @@ +# Webinar Registration Workflow + +Webinar registration workflow with signup form, calendar invite, reminder email sequence, attendance tracking, and post-event follow-up. + +**Template ID:** `webinar-registration-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** onboarding +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [webinar, event-registration, zoom, calendar-invite, reminder-sequence, lead-capture] +**Source path:** `business-operations/webinar-registration` +**Repo path:** `onboarding/business-operations/webinar-registration-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/onboarding/business-operations/webinar-registration-workflow/metadata.json b/onboarding/business-operations/webinar-registration-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..af50a5d5fb0096e4acf6dd9c22ad7ee215b2ace4 --- /dev/null +++ b/onboarding/business-operations/webinar-registration-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "webinar-registration-workflow", + "workflow_id": "webinar-registration", + "title": "Webinar Registration Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "onboarding", + "secondary_use_cases": [], + "use_cases": [ + "onboarding" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "webinar", + "event-registration", + "zoom", + "calendar-invite", + "reminder-sequence", + "lead-capture" + ], + "description": "Webinar registration workflow with signup form, calendar invite, reminder email sequence, attendance tracking, and post-event follow-up.", + "source_path": "business-operations/webinar-registration", + "repo_path": "onboarding/business-operations/webinar-registration-workflow" +} diff --git a/onboarding/business-operations/webinar-registration-workflow/workflow.fz b/onboarding/business-operations/webinar-registration-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..8e3634dff746bcd067dbd582db6234f3373ab714 --- /dev/null +++ b/onboarding/business-operations/webinar-registration-workflow/workflow.fz @@ -0,0 +1,29 @@ +customer { # Customer + n1: circle label:"Start Webinar Registration" + n4: rectangle label:"Make Webinar Registration decision" + n7: rectangle label:"Continue Webinar Registration process" + n10: circle label:"End Webinar Registration" + + n1.handle(bottom) -> agent.n2.handle(top) + n4.handle(bottom) -> agent.n5.handle(top) + n7.handle(bottom) -> agent.n8.handle(top) +} +agent { # Agent + n2: rectangle label:"Receive Webinar Registration request" + n5: diamond label:"Update records for Webinar Registration" + n8: rectangle label:"Continue Webinar Registration process" + + n2.handle(bottom) -> billing.n3.handle(top) [label="Next"] + n5.handle(bottom) -> billing.n6.handle(top) [label="Done"] + n5.handle(right) -> customer.n4.handle(right) [label="Retry/Rejected"] + n8.handle(bottom) -> billing.n9.handle(top) [label="Processed"] +} +billing { # Billing + n3: rectangle label:"Review Webinar Registration details" + n6: rectangle label:"Continue Webinar Registration process" + n9: rectangle label:"Continue Webinar Registration process" + + n3.handle(bottom) -> customer.n4.handle(top) + n6.handle(bottom) -> customer.n7.handle(top) + n9.handle(bottom) -> customer.n10.handle(top) +} \ No newline at end of file diff --git a/onboarding/finance/vendor-onboarding-workflow/README.md b/onboarding/finance/vendor-onboarding-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bfe7366d77a2311b09727a51bafa1e49ff390e76 --- /dev/null +++ b/onboarding/finance/vendor-onboarding-workflow/README.md @@ -0,0 +1,19 @@ +# Vendor Onboarding Workflow + +Vendor onboarding workflow with application review, W-9/W-8BEN verification, insurance certificate validation, background checks, and compliance approval before vendor activation. + +**Template ID:** `vendor-onboarding-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** onboarding +**Secondary use cases:** billing, compliance +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 3 +**Tags:** [vendor-onboarding, supplier-management, w9-verification, insurance-compliance, background-check, payment-terms, procurement] +**Source path:** `finance/vendor-onboarding` +**Repo path:** `onboarding/finance/vendor-onboarding-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/onboarding/finance/vendor-onboarding-workflow/metadata.json b/onboarding/finance/vendor-onboarding-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9a28519111bfc1a56397b77543b6ec36973a5885 --- /dev/null +++ b/onboarding/finance/vendor-onboarding-workflow/metadata.json @@ -0,0 +1,32 @@ +{ + "template_id": "vendor-onboarding-workflow", + "workflow_id": "vendor-onboarding", + "title": "Vendor Onboarding Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "onboarding", + "secondary_use_cases": [ + "billing", + "compliance" + ], + "use_cases": [ + "onboarding", + "billing", + "compliance" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 3, + "tags": [ + "vendor-onboarding", + "supplier-management", + "w9-verification", + "insurance-compliance", + "background-check", + "payment-terms", + "procurement" + ], + "description": "Vendor onboarding workflow with application review, W-9/W-8BEN verification, insurance certificate validation, background checks, and compliance approval before vendor activation.", + "source_path": "finance/vendor-onboarding", + "repo_path": "onboarding/finance/vendor-onboarding-workflow" +} diff --git a/onboarding/finance/vendor-onboarding-workflow/workflow.fz b/onboarding/finance/vendor-onboarding-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b01727e313b6c75fc77407aa2f8a28ba885aa28d --- /dev/null +++ b/onboarding/finance/vendor-onboarding-workflow/workflow.fz @@ -0,0 +1,47 @@ +Vendor { # Vendor +n1: circle label:"Start" +n2: rectangle label:"Submit registration form" +n3: rectangle label:"Upload required documents" +n4: rectangle label:"Receive approval notification" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Procurement.n6.handle(top) [label="Apply"] +n3.handle(bottom) -> Compliance.n12.handle(top) [label="Documents"] +n4.handle(right) -> n5.handle(left) +} +Procurement { # Procurement +n6: rectangle label:"Review vendor application" +n7: diamond label:"Business need valid?" +n8: rectangle label:"Request additional info" +n9: rectangle label:"Assign vendor category" +n10: rectangle label:"Set payment terms" +n11: rectangle label:"Reject application" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n9.handle(left) [label="Yes"] +n7.handle(bottom) -> n8.handle(top) [label="Need info"] +n7.handle(left) -> n11.handle(top) [label="No"] +n8.handle(top) -> Vendor.n3.handle(bottom) [label="Request docs"] +n9.handle(right) -> n10.handle(left) +n10.handle(bottom) -> Compliance.n12.handle(top) [label="Verify"] +n11.handle(top) -> Vendor.n4.handle(bottom) [label="Rejected"] +} +Compliance { # Compliance +n12: rectangle label:"Verify W-9 or W-8BEN" +n13: rectangle label:"Check insurance certificates" +n14: diamond label:"Compliance passed?" +n15: rectangle label:"Run background check" +n16: rectangle label:"Flag compliance issues" +n17: diamond label:"Background clear?" +n18: rectangle label:"Approve vendor" +n19: rectangle label:"Reject vendor" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Yes"] +n14.handle(bottom) -> n16.handle(top) [label="No"] +n15.handle(right) -> n17.handle(left) +n16.handle(top) -> Vendor.n3.handle(bottom) [label="Fix issues"] +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(top) -> Vendor.n4.handle(bottom) [label="Approved"] +n19.handle(top) -> Vendor.n4.handle(bottom) [label="Rejected"] +} diff --git a/onboarding/hr/onboarding-workflow/README.md b/onboarding/hr/onboarding-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d5a012926680a586b93e6eab7d7f9d6cef2e79c7 --- /dev/null +++ b/onboarding/hr/onboarding-workflow/README.md @@ -0,0 +1,19 @@ +# Onboarding Workflow + +Complete employee onboarding workflow covering offer acceptance, HR record creation, benefits enrollment, background check verification, IT account provisioning, equipment setup, and first day orientation. + +**Template ID:** `onboarding-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** onboarding +**Secondary use cases:** delivery +**Complexity:** 4/5 +**Nodes:** 20 +**Lanes:** 3 +**Tags:** [employee-onboarding, new-hire, hr-workflow, background-check, it-provisioning, benefits-enrollment] +**Source path:** `hr/onboarding` +**Repo path:** `onboarding/hr/onboarding-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/onboarding/hr/onboarding-workflow/metadata.json b/onboarding/hr/onboarding-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ac6bc5079c13cca87030c91b9fd5d439868942c3 --- /dev/null +++ b/onboarding/hr/onboarding-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "onboarding-workflow", + "workflow_id": "onboarding", + "title": "Onboarding Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "onboarding", + "secondary_use_cases": [ + "delivery" + ], + "use_cases": [ + "onboarding", + "delivery" + ], + "complexity": 4, + "num_nodes": 20, + "num_lanes": 3, + "tags": [ + "employee-onboarding", + "new-hire", + "hr-workflow", + "background-check", + "it-provisioning", + "benefits-enrollment" + ], + "description": "Complete employee onboarding workflow covering offer acceptance, HR record creation, benefits enrollment, background check verification, IT account provisioning, equipment setup, and first day orientation.", + "source_path": "hr/onboarding", + "repo_path": "onboarding/hr/onboarding-workflow" +} diff --git a/onboarding/hr/onboarding-workflow/workflow.fz b/onboarding/hr/onboarding-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..636ef583ce931015cda290652069fca8b94b864f --- /dev/null +++ b/onboarding/hr/onboarding-workflow/workflow.fz @@ -0,0 +1,47 @@ +NewHire { # New Hire +n1: circle label:"Start" +n2: rectangle label:"Accept offer letter" +n3: rectangle label:"Complete I-9 and W-4 forms" +n4: rectangle label:"Set up direct deposit" +n5: rectangle label:"Complete first day orientation" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> HR.n7.handle(top) [label="Signed"] +n3.handle(bottom) -> IT.n14.handle(top) [label="Docs complete"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +} +HR { # Human Resources +n7: rectangle label:"Create employee record" +n8: rectangle label:"Enroll in benefits" +n9: rectangle label:"Assign to department" +n10: rectangle label:"Schedule orientation" +n11: diamond label:"Background check clear?" +n12: rectangle label:"Proceed with onboarding" +n13: rectangle label:"Rescind offer" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(top) -> NewHire.n3.handle(bottom) [label="Continue"] +n13.handle(top) -> NewHire.n6.handle(bottom) [label="Terminated"] +} +IT { # IT Department +n14: rectangle label:"Create user accounts" +n15: rectangle label:"Provision laptop" +n16: rectangle label:"Set up email and Slack" +n17: rectangle label:"Grant system access" +n18: diamond label:"Equipment ready?" +n19: rectangle label:"Ship to employee" +n20: rectangle label:"Order equipment" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Yes"] +n18.handle(bottom) -> n20.handle(top) [label="No"] +n19.handle(top) -> NewHire.n4.handle(bottom) [label="Ready"] +n20.handle(right) -> n19.handle(top) +} diff --git a/scripts/sync_templates.py b/scripts/sync_templates.py new file mode 100644 index 0000000000000000000000000000000000000000..2fcfb45e36af1dc8045d71fdd15f82fff1458449 --- /dev/null +++ b/scripts/sync_templates.py @@ -0,0 +1,381 @@ +from __future__ import annotations + +import csv +import json +import re +import shutil +import urllib.request +import xml.etree.ElementTree as ET +from collections import Counter +from pathlib import Path + +REPO_ROOT = Path(__file__).resolve().parents[1] +FLOWZAP_APP_ROOT = REPO_ROOT.parent / 'FlowZap-App-v5' +TEMPLATES_INDEX_PATH = FLOWZAP_APP_ROOT / 'src' / 'templateLibrary' / 'templatesIndex.json' +TEMPLATE_FILES_DIR = FLOWZAP_APP_ROOT / 'public' / 'template-files' +SITEMAP_URL = 'https://flowzap.xyz/sitemap-templates.xml' + +USE_CASES = [ + { + 'id': 'handoff', + 'labels': {'en': 'Handoff', 'fr': 'Transfert', 'zh': '交接'}, + 'keywords': ['handoff', 'handover', 'transfer', 'escalation', 'routing', 'handoff degradation'], + }, + { + 'id': 'approval', + 'labels': {'en': 'Approval', 'fr': 'Approbation', 'zh': '审批'}, + 'keywords': ['approval', 'approve', 'sign-off', 'review', 'authorize', 'authorization'], + }, + { + 'id': 'incident', + 'labels': {'en': 'Incident', 'fr': 'Incident', 'zh': '事故'}, + 'keywords': ['incident', 'outage', 'alert', 'on-call', 'monitoring', 'response'], + }, + { + 'id': 'onboarding', + 'labels': {'en': 'Onboarding', 'fr': 'Intégration', 'zh': '入职'}, + 'keywords': ['onboarding', 'onboard', 'welcome', 'setup', 'activation', 'registration'], + }, + { + 'id': 'offboarding', + 'labels': {'en': 'Offboarding', 'fr': 'Départ', 'zh': '离职'}, + 'keywords': ['offboarding', 'termination', 'account deletion', 'deprovision', 'deactivate'], + }, + { + 'id': 'billing', + 'labels': {'en': 'Billing & Payments', 'fr': 'Facturation & paiements', 'zh': '计费与支付'}, + 'keywords': ['billing', 'invoice', 'payment', 'subscription', 'dunning', 'refund', 'dispute', 'chargeback'], + }, + { + 'id': 'security', + 'labels': {'en': 'Security & Access', 'fr': 'Sécurité & accès', 'zh': '安全与访问'}, + 'keywords': ['security', 'auth', 'authentication', 'oauth', '2fa', 'two-factor', 'mfa', 'certificate', 'rotation', 'secret', 'vulnerability', 'patch'], + }, + { + 'id': 'compliance', + 'labels': {'en': 'Compliance', 'fr': 'Conformité', 'zh': '合规'}, + 'keywords': ['gdpr', 'audit', 'compliance', 'consent', 'policy', 'risk', 'controls'], + }, + { + 'id': 'delivery', + 'labels': {'en': 'Delivery & DevOps', 'fr': 'Livraison & DevOps', 'zh': '交付与 DevOps'}, + 'keywords': ['ci/cd', 'ci-cd', 'pipeline', 'deploy', 'deployment', 'rollback', 'migration', 'backup', 'restore', 'provisioning', 'infrastructure', 'load testing'], + }, + { + 'id': 'support', + 'labels': {'en': 'Support', 'fr': 'Support', 'zh': '支持'}, + 'keywords': ['support', 'ticket', 'knowledge base', 'knowledge-base'], + }, + { + 'id': 'agentic', + 'labels': {'en': 'Agentic Teams', 'fr': 'Équipes Agentiques', 'zh': '智能体团队'}, + 'keywords': ['agentic', 'supervisor-worker', 'swarm', 'hierarchical', 'team-of-rivals', 'multi-agent', 'ai-team', 'orchestrator', 'planner', 'critic'], + }, + { + 'id': 'ai-orchestration', + 'labels': {'en': 'AI Orchestration', 'fr': 'Orchestration IA', 'zh': 'AI编排'}, + 'keywords': ['ai-native', 'orchestration', 'single-agent', 'sequential-pipeline', 'parallel-fan-out', 'map-reduce', 'event-driven-mesh', 'competitive', 'generator-critic', 'coordinator'], + }, + { + 'id': 'mcp', + 'labels': {'en': 'MCP Architecture', 'fr': 'Architecture MCP', 'zh': 'MCP架构'}, + 'keywords': ['mcp', 'direct-connect', 'gateway', 'proxy', 'tool-router', 'agent-mesh', 'circuit-breaker', 'context-proxy', 'stdio', 'production-grade'], + }, + { + 'id': 'context-management', + 'labels': {'en': 'Context Management', 'fr': 'Gestion de Contexte', 'zh': '上下文管理'}, + 'keywords': ['context-management', 'session-memory', 'rolling-summary', 'profile-memory', 'semantic-memory', 'episodic-memory', 'hybrid-retrieval', 'shared-memory', 'vector-db', 'memory'], + }, +] + +LEGACY_TOP_LEVEL_DIRS = [ + 'business-operations', + 'devops', + 'edge-cases', + 'finance', + 'hr', + 'logistics', + 'patterns', + 'syntax-primitives', + 'handoff', + 'approval', + 'incident', + 'onboarding', + 'offboarding', + 'billing', + 'security', + 'compliance', + 'delivery', + 'support', + 'agentic', + 'ai-orchestration', + 'mcp', + 'context-management', + 'uncategorized', + 'indexes', +] + + +def normalize_text(value: str) -> str: + return re.sub(r'\s+', ' ', value.lower().replace('_', ' ').replace('-', ' ')).strip() + + +def slugify(value: str) -> str: + return re.sub(r'[^a-z0-9]+', '-', value.lower()).strip('-') or 'unknown' + + +def load_canonical_slugs() -> list[str]: + with urllib.request.urlopen(SITEMAP_URL, timeout=30) as response: + xml_text = response.read().decode('utf-8') + root = ET.fromstring(xml_text) + ns = {'sm': 'http://www.sitemaps.org/schemas/sitemap/0.9'} + slugs: list[str] = [] + seen: set[str] = set() + for loc_node in root.findall('sm:url/sm:loc', ns): + loc = (loc_node.text or '').strip() + if '/fr/templates/' in loc or '/zh/templates/' in loc: + continue + marker = '/templates/' + if marker not in loc: + continue + slug = loc.split(marker, 1)[1].strip('/').removesuffix('.html') + if slug and slug not in seen: + slugs.append(slug) + seen.add(slug) + return slugs + + +def load_app_index() -> dict[str, dict]: + data = json.loads(TEMPLATES_INDEX_PATH.read_text(encoding='utf-8')) + return {entry['slug']: entry for entry in data['templates']} + + +def detect_kind(entry: dict) -> str: + tags = entry.get('tags') or [] + if entry.get('domain') == 'Architecture' or 'architecture-diagram' in tags: + return 'architecture' + return 'workflow' + + +def compute_use_cases(entry: dict) -> list[str]: + haystack = normalize_text( + ' '.join( + str(part) + for part in [entry.get('slug', ''), entry.get('domain', ''), entry.get('sourcePath', ''), *(entry.get('tags') or [])] + if part + ) + ) + matches: list[str] = [] + for use_case in USE_CASES: + if any(normalize_text(keyword) in haystack for keyword in use_case['keywords']): + matches.append(use_case['id']) + return matches + + +def make_readme(entry: dict, primary_use_case: str, secondary_use_cases: list[str], relative_dir: str) -> str: + title = entry['title'] + description = entry.get('description') or '' + source_domain = entry.get('domain') or 'unknown' + tags = entry.get('tags') or [] + lines = [ + f'# {title}', + '', + description, + '', + f'**Template ID:** `{entry["slug"]}` ', + f'**Kind:** {detect_kind(entry)} ', + f'**Source domain:** {source_domain} ', + f'**Primary use case:** {primary_use_case} ', + f'**Secondary use cases:** {", ".join(secondary_use_cases) if secondary_use_cases else "None"} ', + f'**Complexity:** {entry.get("complexity", "n/a")}/5 ', + f'**Nodes:** {entry.get("numNodes", "n/a")} ', + f'**Lanes:** {entry.get("numLanes", "n/a")} ', + f'**Tags:** [{", ".join(tags)}] ', + f'**Source path:** `{entry.get("sourcePath", "")}` ', + f'**Repo path:** `{relative_dir}`', + '', + '## Files', + '- `workflow.fz` — FlowZap Code source', + '- `metadata.json` — Structured metadata', + ] + return '\n'.join(lines).strip() + '\n' + + +def clean_repo_root() -> None: + for name in LEGACY_TOP_LEVEL_DIRS: + path = REPO_ROOT / name + if path.is_dir(): + shutil.rmtree(path) + for name in ('metadata.csv', 'templates.index.json', 'use-cases.index.json', 'README.md', 'CONTRIBUTING.md'): + path = REPO_ROOT / name + if path.exists(): + path.unlink() + + +def write_root_docs(total_templates: int, counts: Counter) -> None: + readme_lines = [ + '# sequence-workflows', + '', + f'A synchronized FlowZap template corpus with **{total_templates} canonical templates** sourced from `https://flowzap.xyz/sitemap-templates.xml` and organized by **primary Use Case**.', + '', + '## Organization Model', + '', + '- Top-level folders are primary Use Cases from the FlowZap Templates dropdown.', + '- Second-level folders preserve the original source domain from the FlowZap app index.', + '- Each template keeps all matched Use Cases in `metadata.json` and the generated JSON/CSV indexes.', + '- Templates that do not match any current dropdown Use Case are placed under `uncategorized/`.', + '', + '## Top-Level Folders', + '', + ] + for use_case in USE_CASES: + readme_lines.append(f'- `{use_case["id"]}/` — {use_case["labels"]["en"]} ({counts.get(use_case["id"], 0)})') + readme_lines.append(f'- `uncategorized/` — Unmatched canonical templates ({counts.get("uncategorized", 0)})') + readme_lines.extend([ + '', + '## Generated Indexes', + '', + '- `templates.index.json` — Full machine-readable template index', + '- `use-cases.index.json` — Use Case summary with counts and template paths', + '- `metadata.csv` — Flat CSV export of core template metadata', + '', + '## Sync Source', + '', + '- Canonical URL source: `https://flowzap.xyz/sitemap-templates.xml`', + '- Template metadata source: `FlowZap-App-v5/src/templateLibrary/templatesIndex.json`', + '- Template file source: `FlowZap-App-v5/public/template-files/*.fz`', + ]) + (REPO_ROOT / 'README.md').write_text('\n'.join(readme_lines).strip() + '\n', encoding='utf-8') + + contributing_lines = [ + '# Contributing', + '', + 'This repository is synchronized from the FlowZap application template library.', + '', + '## Structure', + '', + '- `primary-use-case/source-domain/template-slug/`', + '- `workflow.fz` contains the FlowZap Code source', + '- `metadata.json` stores machine-readable metadata including primary and secondary Use Cases', + '- `templates.index.json`, `use-cases.index.json`, and `metadata.csv` are generated artifacts', + '', + '## Sync Expectations', + '', + '- Keep the sitemap-driven template set aligned with `https://flowzap.xyz/sitemap-templates.xml`.', + '- Preserve one canonical template copy per slug.', + '- Use `primary_use_case` for folder placement and `use_cases` for the full taxonomy membership.', + '- Preserve `source_domain` from the app index for traceability.', + ] + (REPO_ROOT / 'CONTRIBUTING.md').write_text('\n'.join(contributing_lines).strip() + '\n', encoding='utf-8') + + +def main() -> None: + if not FLOWZAP_APP_ROOT.exists(): + raise SystemExit(f'FlowZap app not found at {FLOWZAP_APP_ROOT}') + canonical_slugs = load_canonical_slugs() + app_index = load_app_index() + clean_repo_root() + + templates_index: list[dict] = [] + use_case_index = {use_case['id']: {'label': use_case['labels']['en'], 'count': 0, 'templates': []} for use_case in USE_CASES} + use_case_index['uncategorized'] = {'label': 'Uncategorized', 'count': 0, 'templates': []} + counts: Counter = Counter() + skipped_slugs: list[str] = [] + + for slug in canonical_slugs: + entry = app_index.get(slug) + if entry is None: + skipped_slugs.append(slug) + continue + template_file = TEMPLATE_FILES_DIR / f'{slug}.fz' + if not template_file.exists(): + raise SystemExit(f'Missing template file: {template_file}') + + source_domain = entry.get('domain') or 'unknown' + source_domain_slug = slugify(source_domain) + use_cases = compute_use_cases(entry) + primary_use_case = use_cases[0] if use_cases else 'uncategorized' + secondary_use_cases = use_cases[1:] + kind = detect_kind(entry) + workflow_id = slug[:-9] if slug.endswith('-workflow') else slug + + relative_dir = f'{primary_use_case}/{source_domain_slug}/{slug}' + target_dir = REPO_ROOT / relative_dir + target_dir.mkdir(parents=True, exist_ok=True) + + shutil.copyfile(template_file, target_dir / 'workflow.fz') + + metadata = { + 'template_id': slug, + 'workflow_id': workflow_id, + 'title': entry['title'], + 'kind': kind, + 'source_domain': source_domain, + 'primary_use_case': primary_use_case, + 'secondary_use_cases': secondary_use_cases, + 'use_cases': use_cases, + 'complexity': entry.get('complexity'), + 'num_nodes': entry.get('numNodes'), + 'num_lanes': entry.get('numLanes'), + 'tags': entry.get('tags') or [], + 'description': entry.get('description') or '', + 'source_path': entry.get('sourcePath') or '', + 'repo_path': relative_dir, + } + (target_dir / 'metadata.json').write_text(json.dumps(metadata, indent=2, ensure_ascii=False) + '\n', encoding='utf-8') + (target_dir / 'README.md').write_text(make_readme(entry, primary_use_case, secondary_use_cases, relative_dir), encoding='utf-8') + + record = { + 'slug': slug, + 'title': entry['title'], + 'description': entry.get('description') or '', + 'kind': kind, + 'sourceDomain': source_domain, + 'primaryUseCase': primary_use_case, + 'secondaryUseCases': secondary_use_cases, + 'useCases': use_cases, + 'complexity': entry.get('complexity'), + 'numNodes': entry.get('numNodes'), + 'numLanes': entry.get('numLanes'), + 'tags': entry.get('tags') or [], + 'sourcePath': entry.get('sourcePath') or '', + 'repoPath': relative_dir, + } + templates_index.append(record) + use_case_index[primary_use_case]['count'] += 1 + use_case_index[primary_use_case]['templates'].append({'slug': slug, 'title': entry['title'], 'repoPath': relative_dir}) + counts[primary_use_case] += 1 + + (REPO_ROOT / 'templates.index.json').write_text(json.dumps({'templates': templates_index}, indent=2, ensure_ascii=False) + '\n', encoding='utf-8') + (REPO_ROOT / 'use-cases.index.json').write_text(json.dumps({'useCases': use_case_index}, indent=2, ensure_ascii=False) + '\n', encoding='utf-8') + + with (REPO_ROOT / 'metadata.csv').open('w', encoding='utf-8', newline='') as handle: + writer = csv.DictWriter(handle, fieldnames=['template_id', 'workflow_id', 'title', 'kind', 'source_domain', 'primary_use_case', 'secondary_use_cases', 'use_cases', 'complexity', 'num_nodes', 'num_lanes', 'tags', 'description', 'source_path', 'repo_path']) + writer.writeheader() + for item in templates_index: + writer.writerow({ + 'template_id': item['slug'], + 'workflow_id': item['slug'][:-9] if item['slug'].endswith('-workflow') else item['slug'], + 'title': item['title'], + 'kind': item['kind'], + 'source_domain': item['sourceDomain'], + 'primary_use_case': item['primaryUseCase'], + 'secondary_use_cases': ';'.join(item['secondaryUseCases']), + 'use_cases': ';'.join(item['useCases']), + 'complexity': item['complexity'], + 'num_nodes': item['numNodes'], + 'num_lanes': item['numLanes'], + 'tags': ';'.join(item['tags']), + 'description': item['description'], + 'source_path': item['sourcePath'], + 'repo_path': item['repoPath'], + }) + + write_root_docs(len(templates_index), counts) + if skipped_slugs: + print('Skipped sitemap entries without template metadata:', ', '.join(skipped_slugs)) + print(f'Synchronized {len(templates_index)} templates into {REPO_ROOT}') + + +if __name__ == '__main__': + main() diff --git a/security/architecture/event-driven-domain-events-architecture/README.md b/security/architecture/event-driven-domain-events-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..383f6138d9a554612c733efb06889839996c03a4 --- /dev/null +++ b/security/architecture/event-driven-domain-events-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven Domain Events Architecture + +A domain events architecture diagram showing how aggregate roots raise domain events that are dispatched both in-process to local handlers and cross-boundary to integration event consumers in other bounded contexts. This template models the DDD event pattern where domain logic triggers side effects through a clean event dispatcher, maintaining separation between domain and infrastructure concerns. Key for teams implementing Domain-Driven Design with event-based integration. + +**Template ID:** `event-driven-domain-events-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** security +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [domain-events, ddd, aggregate-root, bounded-context, event-dispatcher, integration-events, domain-driven-design, architecture-diagram] +**Source path:** `` +**Repo path:** `security/architecture/event-driven-domain-events-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/architecture/event-driven-domain-events-architecture/metadata.json b/security/architecture/event-driven-domain-events-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..646dda37e436678232bd23e62857c09eb8ea925d --- /dev/null +++ b/security/architecture/event-driven-domain-events-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "event-driven-domain-events-architecture", + "workflow_id": "event-driven-domain-events-architecture", + "title": "Event-Driven Domain Events Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "security", + "secondary_use_cases": [], + "use_cases": [ + "security" + ], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "domain-events", + "ddd", + "aggregate-root", + "bounded-context", + "event-dispatcher", + "integration-events", + "domain-driven-design", + "architecture-diagram" + ], + "description": "A domain events architecture diagram showing how aggregate roots raise domain events that are dispatched both in-process to local handlers and cross-boundary to integration event consumers in other bounded contexts. This template models the DDD event pattern where domain logic triggers side effects through a clean event dispatcher, maintaining separation between domain and infrastructure concerns. Key for teams implementing Domain-Driven Design with event-based integration.", + "source_path": "", + "repo_path": "security/architecture/event-driven-domain-events-architecture" +} diff --git a/security/architecture/event-driven-domain-events-architecture/workflow.fz b/security/architecture/event-driven-domain-events-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0c2a4aefe7e146e35206e87d42495b1c4befd6ab --- /dev/null +++ b/security/architecture/event-driven-domain-events-architecture/workflow.fz @@ -0,0 +1,42 @@ +Domain { # Domain Layer +n1: circle label:"Business Operation" +n2: rectangle label:"Aggregate Root" +n3: rectangle label:"Apply Domain Logic" +n4: rectangle label:"Raise Domain Event" +n5: rectangle label:"Commit Unit of Work" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="State Transition"] +n3.handle(right) -> n4.handle(left) [label="OrderShipped"] +n4.handle(right) -> n5.handle(left) [label="Transactional"] +n5.handle(bottom) -> Dispatcher.n6.handle(top) [label="After Commit"] +} +Dispatcher { # Event Dispatcher +n6: rectangle label:"Collect Pending Events" +n7: rectangle label:"Resolve Event Handlers" +n8: rectangle label:"Dispatch In-Process" +n9: rectangle label:"Dispatch Cross-Boundary" +n6.handle(right) -> n7.handle(left) [label="Event Queue"] +n7.handle(right) -> n8.handle(left) [label="Same Bounded Context"] +n7.handle(bottom) -> n9.handle(top) [label="External Context"] +n8.handle(bottom) -> Handlers.n10.handle(top) [label="Sync"] +n9.handle(bottom) -> Integration.n14.handle(top) [label="Async"] +} +Handlers { # In-Process Handlers +n10: rectangle label:"Update Read Cache" +n11: rectangle label:"Send Notification" +n12: rectangle label:"Trigger Side Effect" +n13: rectangle label:"Log Audit Entry" +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) +} +Integration { # Integration Events +n14: rectangle label:"Publish to Message Bus" +n15: rectangle label:"Billing Context Subscribes" +n16: rectangle label:"Shipping Context Subscribes" +n17: rectangle label:"Analytics Context Subscribes" +n14.handle(right) -> n15.handle(left) [label="BillingEvent"] +n14.handle(bottom) -> n16.handle(top) [label="ShippingEvent"] +n15.handle(right) -> n17.handle(left) +n16.handle(right) -> n17.handle(left) +} diff --git a/security/architecture/microservices-api-gateway-architecture/README.md b/security/architecture/microservices-api-gateway-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c2f9453841e548555198c51631a798b655bf785c --- /dev/null +++ b/security/architecture/microservices-api-gateway-architecture/README.md @@ -0,0 +1,19 @@ +# Microservices API Gateway Architecture + +A microservices API gateway architecture diagram showing request routing, JWT authentication, rate limiting, service discovery, and response aggregation across distributed backend services. This template models the entry point for all client traffic in a microservices ecosystem, enforcing security policies before requests reach internal services. Ideal for platform engineers designing scalable API infrastructure with centralized cross-cutting concerns. + +**Template ID:** `microservices-api-gateway-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** security +**Secondary use cases:** mcp +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 3 +**Tags:** [microservices, api-gateway, jwt-authentication, rate-limiting, service-discovery, load-balancing, architecture-diagram, distributed-systems] +**Source path:** `` +**Repo path:** `security/architecture/microservices-api-gateway-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/architecture/microservices-api-gateway-architecture/metadata.json b/security/architecture/microservices-api-gateway-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..049c644a79ddb0f40b12299b591412748cb9a452 --- /dev/null +++ b/security/architecture/microservices-api-gateway-architecture/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "microservices-api-gateway-architecture", + "workflow_id": "microservices-api-gateway-architecture", + "title": "Microservices API Gateway Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "security", + "secondary_use_cases": [ + "mcp" + ], + "use_cases": [ + "security", + "mcp" + ], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 3, + "tags": [ + "microservices", + "api-gateway", + "jwt-authentication", + "rate-limiting", + "service-discovery", + "load-balancing", + "architecture-diagram", + "distributed-systems" + ], + "description": "A microservices API gateway architecture diagram showing request routing, JWT authentication, rate limiting, service discovery, and response aggregation across distributed backend services. This template models the entry point for all client traffic in a microservices ecosystem, enforcing security policies before requests reach internal services. Ideal for platform engineers designing scalable API infrastructure with centralized cross-cutting concerns.", + "source_path": "", + "repo_path": "security/architecture/microservices-api-gateway-architecture" +} diff --git a/security/architecture/microservices-api-gateway-architecture/workflow.fz b/security/architecture/microservices-api-gateway-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..248d0f02497ab261a3d50803ee74d107a738ffca --- /dev/null +++ b/security/architecture/microservices-api-gateway-architecture/workflow.fz @@ -0,0 +1,52 @@ +Client { # Client Application +n1: circle label:"Incoming Request" +n2: rectangle label:"Load Balancer" +n21: rectangle label:"Receive API Response" +n22: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Gateway.n3.handle(top) [label="Route Request"] +n21.handle(right) -> n22.handle(left) +} +Gateway { # API Gateway +n3: rectangle label:"Authenticate JWT Token" +n4: diamond label:"Token Valid?" +n5: rectangle label:"Apply Rate Limiting" +n6: rectangle label:"Return 401 Unauthorized" +n7: diamond label:"Rate Limit OK?" +n8: rectangle label:"Route to Microservice" +n9: rectangle label:"Return 429 Throttled" +n18: rectangle label:"Aggregate Responses" +n19: rectangle label:"Format Response" +n20: rectangle label:"Send to Client" +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="Yes"] +n4.handle(bottom) -> n6.handle(top) [label="No"] +n5.handle(right) -> n7.handle(left) +n6.handle(top) -> Client.n21.handle(bottom) [label="401"] +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(bottom) -> n9.handle(top) [label="No"] +n8.handle(bottom) -> Services.n10.handle(top) [label="Forward"] +n9.handle(top) -> Client.n21.handle(bottom) [label="429"] +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(top) -> Client.n21.handle(bottom) [label="Response"] +} +Services { # Microservices Cluster +n10: rectangle label:"Service Discovery Lookup" +n11: rectangle label:"User Service" +n12: rectangle label:"Order Service" +n13: rectangle label:"Inventory Service" +n14: rectangle label:"Compose Response" +n15: rectangle label:"Prepare Aggregated Data" +n16: rectangle label:"Forward Aggregated Data" +n17: rectangle label:"Send to Gateway" +n10.handle(right) -> n11.handle(left) [label="Users"] +n10.handle(bottom) -> n12.handle(top) [label="Orders"] +n11.handle(right) -> n14.handle(left) +n12.handle(right) -> n13.handle(left) [label="Check Stock"] +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> Gateway.n18.handle(bottom) [label="Aggregated"] +} diff --git a/security/architecture/multi-tenant-saas-architecture/README.md b/security/architecture/multi-tenant-saas-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c02bf2f8ccdefa292cd3cae666cf4a2df7232088 --- /dev/null +++ b/security/architecture/multi-tenant-saas-architecture/README.md @@ -0,0 +1,19 @@ +# Multi-Tenant SaaS Architecture + +A multi-tenant SaaS architecture diagram with tenant identification, tier-based routing (shared vs dedicated pools), row-level security, per-tenant encryption keys, and isolated backup strategies for standard and enterprise isolation models. This template models the architecture decisions for building SaaS platforms that serve multiple customers from shared infrastructure while maintaining strict data isolation. Critical for SaaS architects balancing cost efficiency with enterprise security requirements. + +**Template ID:** `multi-tenant-saas-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** security +**Secondary use cases:** delivery +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [multi-tenant, saas-architecture, tenant-isolation, row-level-security, shared-infrastructure, enterprise-tier, data-isolation, architecture-diagram] +**Source path:** `` +**Repo path:** `security/architecture/multi-tenant-saas-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/architecture/multi-tenant-saas-architecture/metadata.json b/security/architecture/multi-tenant-saas-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..952f9354f09252495cc7d993409884c12098368d --- /dev/null +++ b/security/architecture/multi-tenant-saas-architecture/metadata.json @@ -0,0 +1,31 @@ +{ + "template_id": "multi-tenant-saas-architecture", + "workflow_id": "multi-tenant-saas-architecture", + "title": "Multi-Tenant SaaS Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "security", + "secondary_use_cases": [ + "delivery" + ], + "use_cases": [ + "security", + "delivery" + ], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "multi-tenant", + "saas-architecture", + "tenant-isolation", + "row-level-security", + "shared-infrastructure", + "enterprise-tier", + "data-isolation", + "architecture-diagram" + ], + "description": "A multi-tenant SaaS architecture diagram with tenant identification, tier-based routing (shared vs dedicated pools), row-level security, per-tenant encryption keys, and isolated backup strategies for standard and enterprise isolation models. This template models the architecture decisions for building SaaS platforms that serve multiple customers from shared infrastructure while maintaining strict data isolation. Critical for SaaS architects balancing cost efficiency with enterprise security requirements.", + "source_path": "", + "repo_path": "security/architecture/multi-tenant-saas-architecture" +} diff --git a/security/architecture/multi-tenant-saas-architecture/workflow.fz b/security/architecture/multi-tenant-saas-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..333f84ef5ee508e1d0930b41f9632c0d5bb1c61f --- /dev/null +++ b/security/architecture/multi-tenant-saas-architecture/workflow.fz @@ -0,0 +1,50 @@ +Tenant { # Tenant Request +n1: circle label:"Tenant API Call" +n2: rectangle label:"Tenant Identification" +n20: rectangle label:"Receive Response" +n21: circle label:"End" +n1.handle(right) -> n2.handle(left) [label="X-Tenant-ID"] +n2.handle(bottom) -> Routing.n3.handle(top) [label="Resolve Tenant"] +n20.handle(right) -> n21.handle(left) +} +Routing { # Tenant Routing Layer +n3: rectangle label:"Tenant Config Lookup" +n4: diamond label:"Isolation Model?" +n5: rectangle label:"Route to Shared Pool" +n6: rectangle label:"Route to Dedicated Pool" +n7: rectangle label:"Apply Tenant Rate Limits" +n18: rectangle label:"Receive App Response" +n19: rectangle label:"Forward to Tenant" +n3.handle(right) -> n4.handle(left) [label="Tier"] +n4.handle(right) -> n5.handle(left) [label="Standard Tier"] +n4.handle(bottom) -> n6.handle(top) [label="Enterprise Tier"] +n5.handle(right) -> n7.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(bottom) -> Application.n8.handle(top) [label="Tenant Context"] +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> Tenant.n20.handle(bottom) [label="Response"] +} +Application { # Application Layer +n8: rectangle label:"Inject Tenant Context" +n9: rectangle label:"Execute Business Logic" +n10: rectangle label:"Apply Row-Level Security" +n15: rectangle label:"Receive Query Results" +n16: rectangle label:"Return Tenant-Scoped Data" +n17: rectangle label:"Forward to Routing" +n8.handle(right) -> n9.handle(left) [label="Middleware"] +n9.handle(right) -> n10.handle(left) [label="Query"] +n10.handle(bottom) -> DataLayer.n11.handle(top) [label="Tenant Filter"] +n15.handle(right) -> n16.handle(left) [label="Filtered"] +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> Routing.n18.handle(bottom) [label="App Response"] +} +DataLayer { # Data Isolation +n11: rectangle label:"Shared Database (Schema per Tenant)" +n12: rectangle label:"Dedicated Database (Enterprise)" +n13: rectangle label:"Tenant Encryption Keys" +n14: rectangle label:"Return Query Results" +n11.handle(right) -> n13.handle(left) [label="Encrypt at Rest"] +n12.handle(right) -> n13.handle(left) [label="Dedicated Key"] +n13.handle(right) -> n14.handle(left) +n14.handle(top) -> Application.n15.handle(bottom) [label="Data Results"] +} diff --git a/security/architecture/zero-trust-security-architecture/README.md b/security/architecture/zero-trust-security-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8190a6b579fd5b8115921e5621ade559a43f2a71 --- /dev/null +++ b/security/architecture/zero-trust-security-architecture/README.md @@ -0,0 +1,19 @@ +# Zero Trust Security Architecture + +A zero trust security architecture diagram with device posture checks, MFA identity verification, risk-based policy decisions, short-lived JWT tokens, micro-segmentation, mTLS encryption, least-privilege access enforcement, and continuous monitoring. This template models the 'never trust, always verify' security paradigm where every request is authenticated and authorized regardless of network location. Essential for security architects implementing modern zero-trust frameworks in cloud-native environments. + +**Template ID:** `zero-trust-security-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** security +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 4 +**Tags:** [zero-trust, security-architecture, mfa, micro-segmentation, mtls, least-privilege, continuous-verification, architecture-diagram] +**Source path:** `` +**Repo path:** `security/architecture/zero-trust-security-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/architecture/zero-trust-security-architecture/metadata.json b/security/architecture/zero-trust-security-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ceacb7ddd728d0727d7e3adca0db29585dc70d45 --- /dev/null +++ b/security/architecture/zero-trust-security-architecture/metadata.json @@ -0,0 +1,28 @@ +{ + "template_id": "zero-trust-security-architecture", + "workflow_id": "zero-trust-security-architecture", + "title": "Zero Trust Security Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "security", + "secondary_use_cases": [], + "use_cases": [ + "security" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 4, + "tags": [ + "zero-trust", + "security-architecture", + "mfa", + "micro-segmentation", + "mtls", + "least-privilege", + "continuous-verification", + "architecture-diagram" + ], + "description": "A zero trust security architecture diagram with device posture checks, MFA identity verification, risk-based policy decisions, short-lived JWT tokens, micro-segmentation, mTLS encryption, least-privilege access enforcement, and continuous monitoring. This template models the 'never trust, always verify' security paradigm where every request is authenticated and authorized regardless of network location. Essential for security architects implementing modern zero-trust frameworks in cloud-native environments.", + "source_path": "", + "repo_path": "security/architecture/zero-trust-security-architecture" +} diff --git a/security/architecture/zero-trust-security-architecture/workflow.fz b/security/architecture/zero-trust-security-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..05084745258deddc32fb780365504772596ff5cd --- /dev/null +++ b/security/architecture/zero-trust-security-architecture/workflow.fz @@ -0,0 +1,65 @@ +User { # User / Device +n1: circle label:"Access Request" +n2: rectangle label:"Device Posture Check" +n3: rectangle label:"Identity Verification (MFA)" +n28: rectangle label:"Receive Access Decision" +n29: circle label:"Access Granted or Denied" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Device Compliant"] +n3.handle(bottom) -> PolicyEngine.n4.handle(top) [label="Authenticate"] +n28.handle(right) -> n29.handle(left) +} +PolicyEngine { # Policy Decision Point +n4: rectangle label:"Evaluate Identity Context" +n5: rectangle label:"Check Risk Score" +n6: diamond label:"Trust Level Sufficient?" +n7: rectangle label:"Issue Short-Lived Token" +n8: rectangle label:"Deny and Log" +n9: rectangle label:"Step-Up Authentication" +n24: rectangle label:"Receive Enforcement Result" +n25: rectangle label:"Forward to User" +n4.handle(right) -> n5.handle(left) [label="Context"] +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) [label="Trusted"] +n6.handle(bottom) -> n8.handle(top) [label="Denied"] +n6.handle(left) -> n9.handle(right) [label="Elevated"] +n7.handle(bottom) -> Enforcement.n10.handle(top) [label="JWT (5 min TTL)"] +n8.handle(top) -> User.n28.handle(bottom) [label="403"] +n24.handle(right) -> n25.handle(left) +n25.handle(top) -> User.n28.handle(bottom) [label="Access Result"] +} +Enforcement { # Policy Enforcement Points +n10: rectangle label:"Micro-Segmentation Gateway" +n11: rectangle label:"Encrypt All Traffic (mTLS)" +n12: rectangle label:"Least-Privilege Access" +n22: rectangle label:"Receive Resource Response" +n23: rectangle label:"Forward to PolicyEngine" +n26: rectangle label:"Monitoring Dashboard" +n27: rectangle label:"Threat Detection" +n10.handle(right) -> n11.handle(left) [label="Segment"] +n11.handle(right) -> n12.handle(left) [label="Encrypted"] +n12.handle(bottom) -> Resources.n13.handle(top) [label="Scoped Access"] +n22.handle(right) -> n23.handle(left) +n23.handle(top) -> PolicyEngine.n24.handle(bottom) [label="Enforcement Result"] +n26.handle(right) -> n27.handle(left) [label="Detect"] +} +Resources { # Protected Resources +n13: rectangle label:"Application Service" +n14: rectangle label:"Database" +n15: rectangle label:"API Endpoint" +n16: rectangle label:"Audit Log" +n17: rectangle label:"Prepare Response" +n18: rectangle label:"Package Response" +n19: rectangle label:"Forward Response" +n20: rectangle label:"Continuous Monitoring" +n21: rectangle label:"Send to Enforcement" +n13.handle(right) -> n14.handle(left) [label="Query"] +n14.handle(right) -> n15.handle(left) [label="Call"] +n15.handle(right) -> n16.handle(left) [label="Log Access"] +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(top) -> Enforcement.n22.handle(bottom) [label="Resource Response"] +} diff --git a/security/business-operations/api-key-rotation-workflow/README.md b/security/business-operations/api-key-rotation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..86977ea41d57655833d88a25f3bec8f6837fd9b2 --- /dev/null +++ b/security/business-operations/api-key-rotation-workflow/README.md @@ -0,0 +1,19 @@ +# Api Key Rotation Workflow + +API key rotation workflow with new key generation, dual-key transition period, client notification, old key deprecation, and audit logging. + +**Template ID:** `api-key-rotation-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** security +**Secondary use cases:** compliance +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [api-key-rotation, security, credential-management, zero-downtime, secrets-manager, compliance] +**Source path:** `business-operations/api-key-rotation` +**Repo path:** `security/business-operations/api-key-rotation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/business-operations/api-key-rotation-workflow/metadata.json b/security/business-operations/api-key-rotation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..79efc164fa91057afc9ab64bb88e4c9ae2619031 --- /dev/null +++ b/security/business-operations/api-key-rotation-workflow/metadata.json @@ -0,0 +1,29 @@ +{ + "template_id": "api-key-rotation-workflow", + "workflow_id": "api-key-rotation", + "title": "Api Key Rotation Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "security", + "secondary_use_cases": [ + "compliance" + ], + "use_cases": [ + "security", + "compliance" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "api-key-rotation", + "security", + "credential-management", + "zero-downtime", + "secrets-manager", + "compliance" + ], + "description": "API key rotation workflow with new key generation, dual-key transition period, client notification, old key deprecation, and audit logging.", + "source_path": "business-operations/api-key-rotation", + "repo_path": "security/business-operations/api-key-rotation-workflow" +} diff --git a/security/business-operations/api-key-rotation-workflow/workflow.fz b/security/business-operations/api-key-rotation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..46ba024f37c6099a9558fe869ba16918f550f73a --- /dev/null +++ b/security/business-operations/api-key-rotation-workflow/workflow.fz @@ -0,0 +1,47 @@ +Scheduler { # Scheduler + n1: circle label:"Start" + n2: rectangle label:"Trigger rotation job" + n3: rectangle label:"Log rotation event" + n4: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> KeyVault.n5.handle(top) [label="Initiate"] + n3.handle(right) -> n4.handle(left) +} + +KeyVault { # Key Vault + n5: rectangle label:"Generate new API key" + n6: rectangle label:"Store new key securely" + n7: diamond label:"Key generated?" + n8: rectangle label:"Update key metadata" + n5.handle(right) -> n7.handle(left) + n7.handle(right) -> n6.handle(left) [label="Yes"] + n7.handle(bottom) -> n5.handle(bottom) [label="No - Retry"] + n6.handle(right) -> n8.handle(left) + n8.handle(bottom) -> Services.n9.handle(top) [label="Distribute"] + loop [retry up to 3 times] n5 n7 +} + +Services { # Services + n9: rectangle label:"Receive new key" + n10: rectangle label:"Update configuration" + n11: diamond label:"Health check passed?" + n12: rectangle label:"Confirm deployment" + n13: rectangle label:"Rollback to old key" + n9.handle(right) -> n10.handle(left) + n10.handle(right) -> n11.handle(left) + n11.handle(right) -> n12.handle(left) [label="Yes"] + n11.handle(bottom) -> n13.handle(top) [label="No"] + n12.handle(bottom) -> Cleanup.n14.handle(top) [label="Success"] + n13.handle(bottom) -> Cleanup.n17.handle(top) [label="Alert"] +} + +Cleanup { # Cleanup + n14: rectangle label:"Mark old key for deletion" + n15: rectangle label:"Wait grace period" + n16: rectangle label:"Revoke old key" + n17: rectangle label:"Send alert to ops team" + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> n16.handle(left) + n16.handle(top) -> Scheduler.n3.handle(bottom) [label="Complete"] + n17.handle(top) -> Scheduler.n3.handle(bottom) [label="Failed"] +} \ No newline at end of file diff --git a/security/business-operations/sms-verification-workflow/README.md b/security/business-operations/sms-verification-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2ae3ecf9f98db9f3c2578b430c47ca7cbc09cff4 --- /dev/null +++ b/security/business-operations/sms-verification-workflow/README.md @@ -0,0 +1,19 @@ +# Sms Verification Workflow + +SMS phone verification workflow with OTP generation, rate limiting, code validation, retry handling, and verification status tracking. + +**Template ID:** `sms-verification-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** security +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [sms-verification, otp, twilio, phone-verification, 2fa, fraud-prevention] +**Source path:** `business-operations/sms-verification` +**Repo path:** `security/business-operations/sms-verification-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/business-operations/sms-verification-workflow/metadata.json b/security/business-operations/sms-verification-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..744fd120f3cf82580de29dd761a173ac7aafccbc --- /dev/null +++ b/security/business-operations/sms-verification-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "sms-verification-workflow", + "workflow_id": "sms-verification", + "title": "Sms Verification Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "security", + "secondary_use_cases": [], + "use_cases": [ + "security" + ], + "complexity": 3, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "sms-verification", + "otp", + "twilio", + "phone-verification", + "2fa", + "fraud-prevention" + ], + "description": "SMS phone verification workflow with OTP generation, rate limiting, code validation, retry handling, and verification status tracking.", + "source_path": "business-operations/sms-verification", + "repo_path": "security/business-operations/sms-verification-workflow" +} diff --git a/security/business-operations/sms-verification-workflow/workflow.fz b/security/business-operations/sms-verification-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d0e8e27b0fc322c92b14a607858c6e2c2210ea08 --- /dev/null +++ b/security/business-operations/sms-verification-workflow/workflow.fz @@ -0,0 +1,47 @@ +User { # User +n1: circle label:"Start" +n2: rectangle label:"Enter phone number" +n3: rectangle label:"Receive SMS code" +n4: rectangle label:"Enter verification code" +n5: rectangle label:"Access granted" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> App.n7.handle(top) [label="Submit"] +n3.handle(right) -> n4.handle(left) +n4.handle(bottom) -> App.n12.handle(top) [label="Verify"] +n5.handle(right) -> n6.handle(left) +} +App { # Application +n7: rectangle label:"Validate phone format" +n8: diamond label:"Valid E.164 format?" +n9: rectangle label:"Generate 6-digit OTP" +n10: rectangle label:"Store OTP with expiry" +n11: rectangle label:"Return format error" +n12: diamond label:"Code matches?" +n13: rectangle label:"Mark phone verified" +n14: rectangle label:"Increment attempt counter" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n11.handle(top) [label="No"] +n9.handle(right) -> n10.handle(left) +n10.handle(bottom) -> Twilio.n15.handle(top) [label="Send SMS"] +n11.handle(top) -> User.n2.handle(bottom) [label="Try again"] +n12.handle(right) -> n13.handle(left) [label="Yes"] +n12.handle(bottom) -> n14.handle(top) [label="No"] +n13.handle(top) -> User.n5.handle(bottom) [label="Verified"] +n14.handle(top) -> User.n4.handle(bottom) [label="Retry"] +loop [retry up to 3 times] n12 n14 +} +Twilio { # Twilio API +n15: rectangle label:"Format SMS message" +n16: rectangle label:"POST to Messages API" +n17: diamond label:"Delivery status?" +n18: rectangle label:"Log successful delivery" +n19: rectangle label:"Queue for retry" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="delivered"] +n17.handle(bottom) -> n19.handle(top) [label="failed"] +n18.handle(top) -> User.n3.handle(bottom) [label="SMS sent"] +n19.handle(top) -> n16.handle(bottom) [label="Retry"] +} \ No newline at end of file diff --git a/security/devops/certificate-renewal-workflow/README.md b/security/devops/certificate-renewal-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..650f17c9a2bd5eea957b6f05e07f7973385f1a65 --- /dev/null +++ b/security/devops/certificate-renewal-workflow/README.md @@ -0,0 +1,19 @@ +# Certificate Renewal Workflow + +SSL/TLS certificate renewal workflow with expiration monitoring, certificate request by type (DV/OV/EV), domain validation, deployment to load balancers, and health check verification with rollback. + +**Template ID:** `certificate-renewal-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** security +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 3 +**Tags:** [ssl-certificate, tls-renewal, lets-encrypt, certificate-authority, domain-validation, load-balancer, health-check] +**Source path:** `devops/certificate-renewal` +**Repo path:** `security/devops/certificate-renewal-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/devops/certificate-renewal-workflow/metadata.json b/security/devops/certificate-renewal-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..0f4397a9195e438a2b2649c47e4e37dc0be0361f --- /dev/null +++ b/security/devops/certificate-renewal-workflow/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "certificate-renewal-workflow", + "workflow_id": "certificate-renewal", + "title": "Certificate Renewal Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "security", + "secondary_use_cases": [], + "use_cases": [ + "security" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 3, + "tags": [ + "ssl-certificate", + "tls-renewal", + "lets-encrypt", + "certificate-authority", + "domain-validation", + "load-balancer", + "health-check" + ], + "description": "SSL/TLS certificate renewal workflow with expiration monitoring, certificate request by type (DV/OV/EV), domain validation, deployment to load balancers, and health check verification with rollback.", + "source_path": "devops/certificate-renewal", + "repo_path": "security/devops/certificate-renewal-workflow" +} diff --git a/security/devops/certificate-renewal-workflow/workflow.fz b/security/devops/certificate-renewal-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0dc2fe49f1a4d1e128cfbd1edab079179e6f7691 --- /dev/null +++ b/security/devops/certificate-renewal-workflow/workflow.fz @@ -0,0 +1,47 @@ +Monitor { # Certificate Monitor +n1: circle label:"Start" +n2: rectangle label:"Scan certificate inventory" +n3: rectangle label:"Check expiration dates" +n4: rectangle label:"Verify renewal complete" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> CertManager.n6.handle(top) [label="Expiring soon"] +n4.handle(right) -> n5.handle(left) +} +CertManager { # Certificate Manager +n6: diamond label:"Certificate type?" +n7: rectangle label:"Request from Let's Encrypt" +n8: rectangle label:"Request from DigiCert" +n9: rectangle label:"Generate self-signed" +n10: rectangle label:"Complete ACME challenge" +n11: diamond label:"Validation passed?" +n12: rectangle label:"Download new certificate" +n13: rectangle label:"Retry validation" +n6.handle(right) -> n7.handle(left) [label="Public"] +n6.handle(bottom) -> n8.handle(top) [label="Enterprise"] +n6.handle(left) -> n9.handle(top) [label="Internal"] +n7.handle(right) -> n10.handle(left) +n8.handle(right) -> n10.handle(top) +n9.handle(right) -> n12.handle(top) +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(bottom) -> Deployment.n14.handle(top) [label="Install"] +n13.handle(top) -> n10.handle(bottom) [label="Retry"] +} +Deployment { # Certificate Deployment +n14: rectangle label:"Update load balancer" +n15: rectangle label:"Update Kubernetes ingress" +n16: rectangle label:"Reload web servers" +n17: diamond label:"SSL handshake OK?" +n18: rectangle label:"Update certificate inventory" +n19: rectangle label:"Rollback to previous cert" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(top) -> Monitor.n4.handle(bottom) [label="Renewed"] +n19.handle(top) -> CertManager.n6.handle(bottom) [label="Retry"] +} \ No newline at end of file diff --git a/security/devops/mcp-gateway-proxy/README.md b/security/devops/mcp-gateway-proxy/README.md new file mode 100644 index 0000000000000000000000000000000000000000..417051a5645d2af871356865c1c05d04e12a55a3 --- /dev/null +++ b/security/devops/mcp-gateway-proxy/README.md @@ -0,0 +1,19 @@ +# MCP Gateway Proxy Architecture + +An API gateway pattern that sits between agents and MCP servers to handle authentication, rate limits, and auditing. The gateway enforces OAuth 2.0, SAML, SSO, tool-level rate limiting, and team-based quotas. Essential for multi-team or multi-tenant MCP deployments. + +**Template ID:** `mcp-gateway-proxy` +**Kind:** architecture +**Source domain:** DevOps +**Primary use case:** security +**Secondary use cases:** compliance, mcp +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 3 +**Tags:** [mcp, gateway, proxy, oauth, rate-limiting, audit, architecture-diagram, production-grade] +**Source path:** `` +**Repo path:** `security/devops/mcp-gateway-proxy` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/devops/mcp-gateway-proxy/metadata.json b/security/devops/mcp-gateway-proxy/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b1f2d74b1dc2062fe24a3c7c97d5d04fbddd9103 --- /dev/null +++ b/security/devops/mcp-gateway-proxy/metadata.json @@ -0,0 +1,33 @@ +{ + "template_id": "mcp-gateway-proxy", + "workflow_id": "mcp-gateway-proxy", + "title": "MCP Gateway Proxy Architecture", + "kind": "architecture", + "source_domain": "DevOps", + "primary_use_case": "security", + "secondary_use_cases": [ + "compliance", + "mcp" + ], + "use_cases": [ + "security", + "compliance", + "mcp" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 3, + "tags": [ + "mcp", + "gateway", + "proxy", + "oauth", + "rate-limiting", + "audit", + "architecture-diagram", + "production-grade" + ], + "description": "An API gateway pattern that sits between agents and MCP servers to handle authentication, rate limits, and auditing. The gateway enforces OAuth 2.0, SAML, SSO, tool-level rate limiting, and team-based quotas. Essential for multi-team or multi-tenant MCP deployments.", + "source_path": "", + "repo_path": "security/devops/mcp-gateway-proxy" +} diff --git a/security/devops/mcp-gateway-proxy/workflow.fz b/security/devops/mcp-gateway-proxy/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..f1ff5ff90b492408a02a6e7d84a9c27483491975 --- /dev/null +++ b/security/devops/mcp-gateway-proxy/workflow.fz @@ -0,0 +1,32 @@ +Host { # Host Application + n1: circle label="User sends prompt" + n2: rectangle label="Agent builds tool call" + n3: rectangle label="Send request to gateway" + n4: rectangle label="Receive gateway response" + n5: rectangle label="Agent responds to user" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> Gateway.n6.handle(top) [label="Tool request"] + n4.handle(right) -> n5.handle(left) +} + +Gateway { # MCP Gateway + n6: rectangle label="Receive and log request" + n7: diamond label="Authorized?" + n8: rectangle label="Forward to MCP server" + n9: rectangle label="Receive MCP response" + n10: rectangle label="Log response and return" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) [label="Yes"] + n7.handle(top) -> Host.n4.handle(left) [label="401 Unauthorized"] + n8.handle(bottom) -> MCPServer.n11.handle(top) [label="Forwarded request"] + n9.handle(right) -> n10.handle(left) + n10.handle(top) -> Host.n4.handle(bottom) [label="Authorized response"] +} + +MCPServer { # MCP Server + n11: rectangle label="Execute tool" + n12: rectangle label="Return result" + n11.handle(right) -> n12.handle(left) + n12.handle(top) -> Gateway.n9.handle(bottom) [label="Tool result"] +} diff --git a/security/devops/secret-rotation-workflow/README.md b/security/devops/secret-rotation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..69c38720913fd57c063464a5bfeb9d0e5f482952 --- /dev/null +++ b/security/devops/secret-rotation-workflow/README.md @@ -0,0 +1,19 @@ +# Secret Rotation Workflow + +Automated secret rotation workflow with HashiCorp Vault for API keys, database passwords, and certificates including Kubernetes secret updates and rolling service restarts. + +**Template ID:** `secret-rotation-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** security +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 3 +**Tags:** [secret-rotation, vault, kubernetes-secrets, api-keys, database-passwords, certificates, security] +**Source path:** `devops/secret-rotation` +**Repo path:** `security/devops/secret-rotation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/devops/secret-rotation-workflow/metadata.json b/security/devops/secret-rotation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f3c92f9e0684cb007fcbaa087dc2e7787d667de3 --- /dev/null +++ b/security/devops/secret-rotation-workflow/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "secret-rotation-workflow", + "workflow_id": "secret-rotation", + "title": "Secret Rotation Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "security", + "secondary_use_cases": [], + "use_cases": [ + "security" + ], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 3, + "tags": [ + "secret-rotation", + "vault", + "kubernetes-secrets", + "api-keys", + "database-passwords", + "certificates", + "security" + ], + "description": "Automated secret rotation workflow with HashiCorp Vault for API keys, database passwords, and certificates including Kubernetes secret updates and rolling service restarts.", + "source_path": "devops/secret-rotation", + "repo_path": "security/devops/secret-rotation-workflow" +} diff --git a/security/devops/secret-rotation-workflow/workflow.fz b/security/devops/secret-rotation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..cb3f84607b3864202793f2f61065d7940d90259a --- /dev/null +++ b/security/devops/secret-rotation-workflow/workflow.fz @@ -0,0 +1,44 @@ +Scheduler { # Rotation Scheduler +n1: circle label:"Start" +n2: rectangle label:"Check secret expiration dates" +n3: rectangle label:"Identify secrets due for rotation" +n4: rectangle label:"Verify rotation complete" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Vault.n6.handle(top) [label="Rotate"] +n4.handle(right) -> n5.handle(left) +} +Vault { # Secret Vault +n6: rectangle label:"Generate new secret value" +n7: rectangle label:"Store new version" +n8: diamond label:"Secret type?" +n9: rectangle label:"Rotate API key" +n10: rectangle label:"Rotate database password" +n11: rectangle label:"Rotate certificate" +n12: rectangle label:"Update secret metadata" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="API key"] +n8.handle(bottom) -> n10.handle(top) [label="DB password"] +n8.handle(left) -> n11.handle(top) [label="Certificate"] +n9.handle(bottom) -> n12.handle(top) +n10.handle(bottom) -> n12.handle(top) +n11.handle(bottom) -> n12.handle(top) +n12.handle(bottom) -> Deployment.n13.handle(top) [label="Deploy"] +} +Deployment { # Secret Deployment +n13: rectangle label:"Update Kubernetes secrets" +n14: rectangle label:"Trigger rolling restart" +n15: diamond label:"Services healthy?" +n16: rectangle label:"Mark rotation successful" +n17: rectangle label:"Rollback to previous" +n18: rectangle label:"Send rotation report" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(right) -> n18.handle(left) +n17.handle(right) -> n18.handle(top) +n18.handle(top) -> Scheduler.n4.handle(bottom) [label="Complete"] +} diff --git a/security/devops/security-scan-workflow/README.md b/security/devops/security-scan-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..30da9a9a7b537f36a8bb51790bf7bf523a91807c --- /dev/null +++ b/security/devops/security-scan-workflow/README.md @@ -0,0 +1,19 @@ +# Security Scan Workflow + +Security scanning workflow with SAST, DAST, dependency vulnerability scanning, finding triage, and remediation tracking in CI/CD pipeline. + +**Template ID:** `security-scan-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** security +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [security-scanning, sast, dast, dependency-check, snyk, devsecops] +**Source path:** `devops/security-scan` +**Repo path:** `security/devops/security-scan-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/devops/security-scan-workflow/metadata.json b/security/devops/security-scan-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..58332fc8c8d674eb714be0b5935ae703d4a6857f --- /dev/null +++ b/security/devops/security-scan-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "security-scan-workflow", + "workflow_id": "security-scan", + "title": "Security Scan Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "security", + "secondary_use_cases": [], + "use_cases": [ + "security" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "security-scanning", + "sast", + "dast", + "dependency-check", + "snyk", + "devsecops" + ], + "description": "Security scanning workflow with SAST, DAST, dependency vulnerability scanning, finding triage, and remediation tracking in CI/CD pipeline.", + "source_path": "devops/security-scan", + "repo_path": "security/devops/security-scan-workflow" +} diff --git a/security/devops/security-scan-workflow/workflow.fz b/security/devops/security-scan-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..230ddfc98e5f95697efc557f2a7afb91b8da7209 --- /dev/null +++ b/security/devops/security-scan-workflow/workflow.fz @@ -0,0 +1,53 @@ +CI { # CI Pipeline +n1: circle label:"Start" +n2: rectangle label:"Checkout code" +n3: rectangle label:"Install dependencies" +n4: rectangle label:"Trigger security scans" +n5: rectangle label:"Review scan results" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(bottom) -> SAST.n7.handle(top) [label="Static analysis"] +n4.handle(bottom) -> SCA.n12.handle(top) [label="Dependency scan"] +n5.handle(right) -> n6.handle(left) +} +SAST { # Static Analysis +n7: rectangle label:"Run Semgrep rules" +n8: rectangle label:"Scan for secrets" +n9: diamond label:"Critical findings?" +n10: rectangle label:"Generate SARIF report" +n11: rectangle label:"Block pipeline" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="No"] +n9.handle(bottom) -> n11.handle(top) [label="Yes"] +n10.handle(bottom) -> SecurityDashboard.n17.handle(top) [label="Upload"] +n11.handle(top) -> CI.n5.handle(bottom) [label="Failed"] +} +SCA { # Software Composition Analysis +n12: rectangle label:"Parse dependency manifest" +n13: rectangle label:"Check CVE databases" +n14: diamond label:"High severity CVEs?" +n15: rectangle label:"Generate SBOM" +n16: rectangle label:"Flag vulnerable packages" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="No"] +n14.handle(bottom) -> n16.handle(top) [label="Yes"] +n15.handle(bottom) -> SecurityDashboard.n17.handle(top) [label="Upload"] +n16.handle(bottom) -> SecurityDashboard.n17.handle(top) [label="Report"] +} +SecurityDashboard { # Security Dashboard +n17: rectangle label:"Aggregate scan results" +n18: rectangle label:"Calculate risk score" +n19: diamond label:"Meets security policy?" +n20: rectangle label:"Approve for deployment" +n21: rectangle label:"Create remediation tickets" +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) [label="Yes"] +n19.handle(bottom) -> n21.handle(top) [label="No"] +n20.handle(top) -> CI.n5.handle(bottom) [label="Passed"] +n21.handle(top) -> CI.n5.handle(bottom) [label="Action required"] +} diff --git a/security/devops/vulnerability-patch-workflow/README.md b/security/devops/vulnerability-patch-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..666c898e16bf0350a407b48c84f49c2828d210d8 --- /dev/null +++ b/security/devops/vulnerability-patch-workflow/README.md @@ -0,0 +1,19 @@ +# Vulnerability Patch Workflow + +Security vulnerability patching workflow with CVE scanning, severity-based triage (critical/high/medium), patch testing, staging deployment, and production rollout with rollback capability. + +**Template ID:** `vulnerability-patch-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** security +**Secondary use cases:** compliance, delivery +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 3 +**Tags:** [vulnerability-management, security-patching, cve-triage, cvss-scoring, patch-testing, rollback, compliance] +**Source path:** `devops/vulnerability-patch` +**Repo path:** `security/devops/vulnerability-patch-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/devops/vulnerability-patch-workflow/metadata.json b/security/devops/vulnerability-patch-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3aedd4d13a9e4161f1c014bceea664ad9f64228f --- /dev/null +++ b/security/devops/vulnerability-patch-workflow/metadata.json @@ -0,0 +1,32 @@ +{ + "template_id": "vulnerability-patch-workflow", + "workflow_id": "vulnerability-patch", + "title": "Vulnerability Patch Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "security", + "secondary_use_cases": [ + "compliance", + "delivery" + ], + "use_cases": [ + "security", + "compliance", + "delivery" + ], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 3, + "tags": [ + "vulnerability-management", + "security-patching", + "cve-triage", + "cvss-scoring", + "patch-testing", + "rollback", + "compliance" + ], + "description": "Security vulnerability patching workflow with CVE scanning, severity-based triage (critical/high/medium), patch testing, staging deployment, and production rollout with rollback capability.", + "source_path": "devops/vulnerability-patch", + "repo_path": "security/devops/vulnerability-patch-workflow" +} diff --git a/security/devops/vulnerability-patch-workflow/workflow.fz b/security/devops/vulnerability-patch-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..74b81cc5d50f38f058c23424a969498203cc2e97 --- /dev/null +++ b/security/devops/vulnerability-patch-workflow/workflow.fz @@ -0,0 +1,47 @@ +Scanner { # Vulnerability Scanner +n1: circle label:"Start" +n2: rectangle label:"Run dependency scan" +n3: rectangle label:"Analyze CVE database" +n4: rectangle label:"Verify patch applied" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Triage.n6.handle(top) [label="Vulnerabilities found"] +n4.handle(right) -> n5.handle(left) +} +Triage { # Vulnerability Triage +n6: rectangle label:"Assess CVSS score" +n7: diamond label:"Severity level?" +n8: rectangle label:"Create critical ticket" +n9: rectangle label:"Create high priority ticket" +n10: rectangle label:"Add to backlog" +n11: rectangle label:"Assign to security team" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Critical"] +n7.handle(bottom) -> n9.handle(top) [label="High"] +n7.handle(left) -> n10.handle(top) [label="Medium/Low"] +n8.handle(right) -> n11.handle(left) +n9.handle(right) -> n11.handle(top) +n10.handle(top) -> Scanner.n4.handle(bottom) [label="Scheduled"] +n11.handle(bottom) -> Patching.n12.handle(top) [label="Remediate"] +} +Patching { # Patch Application +n12: rectangle label:"Update dependency version" +n13: rectangle label:"Run regression tests" +n14: diamond label:"Tests pass?" +n15: rectangle label:"Deploy to staging" +n16: rectangle label:"Investigate failures" +n17: diamond label:"Staging healthy?" +n18: rectangle label:"Deploy to production" +n19: rectangle label:"Rollback changes" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Yes"] +n14.handle(bottom) -> n16.handle(top) [label="No"] +n15.handle(right) -> n17.handle(left) +n16.handle(top) -> n12.handle(bottom) [label="Fix"] +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(top) -> Scanner.n4.handle(bottom) [label="Patched"] +n19.handle(top) -> n12.handle(bottom) [label="Retry"] +} diff --git a/security/logistics/shipping-process-workflow/README.md b/security/logistics/shipping-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5502aca40fd0705a8668bb24c664e6c155919f59 --- /dev/null +++ b/security/logistics/shipping-process-workflow/README.md @@ -0,0 +1,19 @@ +# Shipping Process Workflow + +Order shipping workflow with carrier selection, rate shopping, label generation, tracking number assignment, and dispatch confirmation. + +**Template ID:** `shipping-process-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** security +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [shipping-process, order-fulfillment, carrier-selection, label-generation, tracking-number, dispatch] +**Source path:** `logistics/shipping-process` +**Repo path:** `security/logistics/shipping-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/logistics/shipping-process-workflow/metadata.json b/security/logistics/shipping-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d98a93faea649f0cb50d0ec5dd4925b219f7b9a6 --- /dev/null +++ b/security/logistics/shipping-process-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "shipping-process-workflow", + "workflow_id": "shipping-process", + "title": "Shipping Process Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "security", + "secondary_use_cases": [], + "use_cases": [ + "security" + ], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "shipping-process", + "order-fulfillment", + "carrier-selection", + "label-generation", + "tracking-number", + "dispatch" + ], + "description": "Order shipping workflow with carrier selection, rate shopping, label generation, tracking number assignment, and dispatch confirmation.", + "source_path": "logistics/shipping-process", + "repo_path": "security/logistics/shipping-process-workflow" +} diff --git a/security/logistics/shipping-process-workflow/workflow.fz b/security/logistics/shipping-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3803fbed8d1891e5509dc9af2e189d2d42f24a06 --- /dev/null +++ b/security/logistics/shipping-process-workflow/workflow.fz @@ -0,0 +1,48 @@ +OrderSystem { # Order System +n1: circle label:"Start" +n2: rectangle label:"Receive shipping request" +n3: rectangle label:"Validate shipping address" +n4: rectangle label:"Update tracking status" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Warehouse.n6.handle(top) [label="Pick order"] +n3.handle(bottom) -> Carrier.n14.handle(top) [label="Ship"] +n4.handle(right) -> n5.handle(left) +} +Warehouse { # Warehouse +n6: rectangle label:"Locate items in inventory" +n7: rectangle label:"Pick items from shelves" +n8: diamond label:"All items available?" +n9: rectangle label:"Pack items securely" +n10: rectangle label:"Flag backorder items" +n11: rectangle label:"Generate packing slip" +n12: rectangle label:"Apply shipping label" +n13: rectangle label:"Move to shipping dock" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(top) -> OrderSystem.n4.handle(bottom) [label="Partial ship"] +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) +n13.handle(top) -> OrderSystem.n3.handle(bottom) [label="Ready"] +} +Carrier { # Carrier +n14: rectangle label:"Scan package barcode" +n15: rectangle label:"Load onto delivery vehicle" +n16: rectangle label:"Update tracking number" +n17: diamond label:"Delivery attempt?" +n18: rectangle label:"Deliver to recipient" +n19: rectangle label:"Leave at door" +n20: rectangle label:"Return to facility" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Recipient home"] +n17.handle(bottom) -> n19.handle(top) [label="Safe location"] +n17.handle(left) -> n20.handle(top) [label="Failed"] +n18.handle(top) -> OrderSystem.n4.handle(bottom) [label="Delivered"] +n19.handle(top) -> OrderSystem.n4.handle(bottom) [label="Delivered"] +n20.handle(top) -> OrderSystem.n4.handle(bottom) [label="Exception"] +} diff --git a/security/patterns/authentication-flow-workflow/README.md b/security/patterns/authentication-flow-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..475c07b65ef464aba9838438ad68744bdb607826 --- /dev/null +++ b/security/patterns/authentication-flow-workflow/README.md @@ -0,0 +1,19 @@ +# Authentication Flow Workflow + +User authentication workflow with credential validation, MFA challenge, JWT token generation, session creation, and failed attempt tracking. + +**Template ID:** `authentication-flow-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** security +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [authentication, login, jwt, oauth, mfa, session-management] +**Source path:** `patterns/authentication-flow` +**Repo path:** `security/patterns/authentication-flow-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/security/patterns/authentication-flow-workflow/metadata.json b/security/patterns/authentication-flow-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bc9678df70542500717b92f5d7c4f8cd4e18410c --- /dev/null +++ b/security/patterns/authentication-flow-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "authentication-flow-workflow", + "workflow_id": "authentication-flow", + "title": "Authentication Flow Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "security", + "secondary_use_cases": [], + "use_cases": [ + "security" + ], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "authentication", + "login", + "jwt", + "oauth", + "mfa", + "session-management" + ], + "description": "User authentication workflow with credential validation, MFA challenge, JWT token generation, session creation, and failed attempt tracking.", + "source_path": "patterns/authentication-flow", + "repo_path": "security/patterns/authentication-flow-workflow" +} diff --git a/security/patterns/authentication-flow-workflow/workflow.fz b/security/patterns/authentication-flow-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..70bdb88c9f44d96880cacd276a1d0fe5ba32216e --- /dev/null +++ b/security/patterns/authentication-flow-workflow/workflow.fz @@ -0,0 +1,47 @@ +User { # User +n1: circle label:"Start" +n2: rectangle label:"Enter credentials" +n3: rectangle label:"Submit login form" +n4: rectangle label:"Receive access token" +n5: rectangle label:"Access protected resource" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> AuthServer.n7.handle(top) [label="Login request"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) +} +AuthServer { # Auth Server +n7: rectangle label:"Receive credentials" +n8: rectangle label:"Lookup user in database" +n9: diamond label:"User exists?" +n10: rectangle label:"Verify password hash" +n11: rectangle label:"Return invalid user" +n12: diamond label:"Password correct?" +n13: diamond label:"MFA enabled?" +n14: rectangle label:"Return invalid password" +n15: rectangle label:"Generate JWT token" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n11.handle(top) [label="No"] +n10.handle(right) -> n12.handle(left) +n11.handle(top) -> User.n2.handle(bottom) [label="Try again"] +n12.handle(right) -> n13.handle(left) [label="Yes"] +n12.handle(bottom) -> n14.handle(top) [label="No"] +n13.handle(right) -> n15.handle(left) [label="No"] +n13.handle(bottom) -> MFA.n16.handle(top) [label="Yes"] +n14.handle(top) -> User.n2.handle(bottom) [label="Try again"] +n15.handle(top) -> User.n4.handle(bottom) [label="Token issued"] +} +MFA { # Multi-Factor Auth +n16: rectangle label:"Send OTP to device" +n17: rectangle label:"Verify OTP code" +n18: diamond label:"OTP valid?" +n19: rectangle label:"Return MFA failure" +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> AuthServer.n15.handle(bottom) [label="Yes"] +n18.handle(bottom) -> n19.handle(top) [label="No"] +n19.handle(top) -> User.n2.handle(bottom) [label="Retry"] +} diff --git a/support/business-operations/knowledge-base-workflow/README.md b/support/business-operations/knowledge-base-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..00491734720e5678ce016403345ad26bf7e2af92 --- /dev/null +++ b/support/business-operations/knowledge-base-workflow/README.md @@ -0,0 +1,19 @@ +# Knowledge Base Workflow + +Knowledge base management workflow with article creation, review approval, SEO optimization, version control, and search analytics tracking. + +**Template ID:** `knowledge-base-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** support +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [knowledge-base, help-center, documentation, self-service, article-management, zendesk] +**Source path:** `business-operations/knowledge-base` +**Repo path:** `support/business-operations/knowledge-base-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/support/business-operations/knowledge-base-workflow/metadata.json b/support/business-operations/knowledge-base-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..02d62f8c12d206ae533313baedd674d64238f989 --- /dev/null +++ b/support/business-operations/knowledge-base-workflow/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "knowledge-base-workflow", + "workflow_id": "knowledge-base", + "title": "Knowledge Base Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "support", + "secondary_use_cases": [], + "use_cases": [ + "support" + ], + "complexity": 3, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "knowledge-base", + "help-center", + "documentation", + "self-service", + "article-management", + "zendesk" + ], + "description": "Knowledge base management workflow with article creation, review approval, SEO optimization, version control, and search analytics tracking.", + "source_path": "business-operations/knowledge-base", + "repo_path": "support/business-operations/knowledge-base-workflow" +} diff --git a/support/business-operations/knowledge-base-workflow/workflow.fz b/support/business-operations/knowledge-base-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..5dd481d6f77d8176d53b37b59baf1c56180f135a --- /dev/null +++ b/support/business-operations/knowledge-base-workflow/workflow.fz @@ -0,0 +1,44 @@ +Author { # Content Author + n1: circle label:"Start" + n2: rectangle label:"Draft article content" + n3: rectangle label:"Add media attachments" + n4: rectangle label:"Receive publication notice" + n5: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> Review.n6.handle(top) [label="Submit"] + n4.handle(right) -> n5.handle(left) +} +Review { # Editorial Review + n6: rectangle label:"Check content accuracy" + n7: rectangle label:"Review SEO optimization" + n8: diamond label:"Content quality?" + n9: rectangle label:"Approve for publication" + n10: rectangle label:"Request revisions" + n11: rectangle label:"Reject article" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n8.handle(right) -> n9.handle(left) [label="Approved"] + n8.handle(bottom) -> n10.handle(top) [label="Needs work"] + n8.handle(left) -> n11.handle(top) [label="Rejected"] + n9.handle(bottom) -> CMS.n12.handle(top) [label="Publish"] + n10.handle(top) -> Author.n2.handle(bottom) [label="Revise"] + n11.handle(top) -> Author.n5.handle(bottom) [label="Closed"] +} +CMS { # Content Management System + n12: rectangle label:"Assign categories and tags" + n13: rectangle label:"Generate URL slug" + n14: rectangle label:"Index for search" + n15: rectangle label:"Publish to live site" + n16: diamond label:"Featured article?" + n17: rectangle label:"Add to homepage" + n18: rectangle label:"Standard listing" + n12.handle(right) -> n13.handle(left) + n13.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> n16.handle(left) + n16.handle(right) -> n17.handle(left) [label="Yes"] + n16.handle(bottom) -> n18.handle(top) [label="No"] + n17.handle(top) -> Author.n4.handle(bottom) [label="Published"] + n18.handle(top) -> Author.n4.handle(bottom) [label="Published"] +} \ No newline at end of file diff --git a/templates.index.json b/templates.index.json new file mode 100644 index 0000000000000000000000000000000000000000..8f5aa45e430b612f84e23552271b77833cadba6b --- /dev/null +++ b/templates.index.json @@ -0,0 +1,6050 @@ +{ + "templates": [ + { + "slug": "a-b-testing-workflow", + "title": "A B Testing Workflow", + "description": "This workflow models comparing two versions to see which performs better.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "a", + "b", + "testing", + "patterns" + ], + "sourcePath": "patterns/a-b-testing", + "repoPath": "uncategorized/patterns/a-b-testing-workflow" + }, + { + "slug": "ab-test-setup-workflow", + "title": "Ab Test Setup Workflow", + "description": "A/B test setup workflow with hypothesis definition, variant creation, traffic allocation, statistical analysis, and winner deployment.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "onboarding", + "secondaryUseCases": [], + "useCases": [ + "onboarding" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "ab-testing", + "experimentation", + "split-testing", + "statistical-significance", + "conversion-optimization", + "optimizely" + ], + "sourcePath": "business-operations/ab-test-setup", + "repoPath": "onboarding/business-operations/ab-test-setup-workflow" + }, + { + "slug": "access-review-workflow", + "title": "Access Review Workflow", + "description": "Quarterly user access review workflow with manager certification, separation of duties validation, remediation tracking, and compliance reporting for audit purposes.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "compliance" + ], + "useCases": [ + "approval", + "compliance" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 3, + "tags": [ + "access-review", + "user-access-certification", + "quarterly-review", + "manager-approval", + "compliance", + "sod-violations", + "audit" + ], + "sourcePath": "devops/access-review", + "repoPath": "approval/devops/access-review-workflow" + }, + { + "slug": "account-deletion-workflow", + "title": "Account Deletion Workflow", + "description": "Account deletion workflow with cancellation reason capture, retention offer, subscription termination, data cleanup, and confirmation email.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "offboarding", + "secondaryUseCases": [ + "billing" + ], + "useCases": [ + "offboarding", + "billing" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "account-deletion", + "user-offboarding", + "data-cleanup", + "subscription-cancel", + "retention-offer", + "exit-survey" + ], + "sourcePath": "business-operations/account-deletion", + "repoPath": "offboarding/business-operations/account-deletion-workflow" + }, + { + "slug": "api-gateway-workflow", + "title": "Api Gateway Workflow", + "description": "API Gateway pattern with request authentication, rate limiting, request routing to backend services, response aggregation, and error handling.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "handoff", + "secondaryUseCases": [ + "security", + "mcp" + ], + "useCases": [ + "handoff", + "security", + "mcp" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "api-gateway", + "microservices", + "rate-limiting", + "request-routing", + "authentication", + "load-balancing" + ], + "sourcePath": "patterns/api-gateway", + "repoPath": "handoff/patterns/api-gateway-workflow" + }, + { + "slug": "api-key-rotation-workflow", + "title": "Api Key Rotation Workflow", + "description": "API key rotation workflow with new key generation, dual-key transition period, client notification, old key deprecation, and audit logging.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "security", + "secondaryUseCases": [ + "compliance" + ], + "useCases": [ + "security", + "compliance" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "api-key-rotation", + "security", + "credential-management", + "zero-downtime", + "secrets-manager", + "compliance" + ], + "sourcePath": "business-operations/api-key-rotation", + "repoPath": "security/business-operations/api-key-rotation-workflow" + }, + { + "slug": "audit-trail-workflow", + "title": "Audit Trail Workflow", + "description": "This workflow models logging all important actions for compliance.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "audit", + "trail", + "patterns", + "decision", + "loop" + ], + "sourcePath": "patterns/audit-trail", + "repoPath": "compliance/patterns/audit-trail-workflow" + }, + { + "slug": "authentication-flow-workflow", + "title": "Authentication Flow Workflow", + "description": "User authentication workflow with credential validation, MFA challenge, JWT token generation, session creation, and failed attempt tracking.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "security", + "secondaryUseCases": [], + "useCases": [ + "security" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "authentication", + "login", + "jwt", + "oauth", + "mfa", + "session-management" + ], + "sourcePath": "patterns/authentication-flow", + "repoPath": "security/patterns/authentication-flow-workflow" + }, + { + "slug": "authorization-flow-workflow", + "title": "Authorization Flow Workflow", + "description": "This workflow models checking user permissions before actions run.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "security" + ], + "useCases": [ + "approval", + "security" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "authorization", + "flow", + "patterns" + ], + "sourcePath": "patterns/authorization-flow", + "repoPath": "approval/patterns/authorization-flow-workflow" + }, + { + "slug": "background-check-workflow", + "title": "Background Check Workflow", + "description": "Pre-employment background check workflow with criminal history search, employment verification, education verification, and drug screening coordination.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "background-check", + "pre-employment", + "criminal-history", + "employment-verification", + "education-verification", + "drug-screening" + ], + "sourcePath": "hr/background-check", + "repoPath": "uncategorized/hr/background-check-workflow" + }, + { + "slug": "backup-restore-workflow", + "title": "Backup Restore Workflow", + "description": "Backup and restore workflow with scheduled backups, offsite replication, retention policy enforcement, restore testing, and RTO/RPO validation.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "backup-restore", + "disaster-recovery", + "rpo-rto", + "snapshot", + "data-protection", + "recovery-testing" + ], + "sourcePath": "devops/backup-restore", + "repoPath": "delivery/devops/backup-restore-workflow" + }, + { + "slug": "bank-reconciliation-workflow", + "title": "Bank Reconciliation Workflow", + "description": "Bank reconciliation workflow with automated transaction matching, variance reporting, discrepancy research, and journal entry creation for timing differences and bank errors.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 18, + "numLanes": 3, + "tags": [ + "bank-reconciliation", + "gl-matching", + "variance-analysis", + "journal-entries", + "auto-matching", + "discrepancy-resolution" + ], + "sourcePath": "finance/bank-reconciliation", + "repoPath": "uncategorized/finance/bank-reconciliation-workflow" + }, + { + "slug": "batch-processing-workflow", + "title": "Batch Processing Workflow", + "description": "Batch processing pattern with job scheduling, chunk-based processing, checkpoint/restart capability, error handling, and completion reporting.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "batch-processing", + "scheduled-jobs", + "bulk-operations", + "etl", + "chunk-processing", + "job-scheduler" + ], + "sourcePath": "patterns/batch-processing", + "repoPath": "uncategorized/patterns/batch-processing-workflow" + }, + { + "slug": "billing-dispute-workflow", + "title": "Billing Dispute Workflow", + "description": "Billing dispute workflow with dispute intake, transaction review, fraud analysis, resolution decision, and chargeback response handling.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "billing" + ], + "useCases": [ + "approval", + "billing" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "billing-dispute", + "chargeback", + "refund-request", + "dispute-resolution", + "fraud-review", + "stripe" + ], + "sourcePath": "business-operations/billing-dispute", + "repoPath": "approval/business-operations/billing-dispute-workflow" + }, + { + "slug": "blue-green-deploy-workflow", + "title": "Blue Green Deploy Workflow", + "description": "Blue-green deployment pattern with parallel environment setup, smoke testing, load balancer traffic switch, and instant rollback capability.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "blue-green-deployment", + "zero-downtime", + "traffic-switching", + "rollback", + "load-balancer", + "release-management" + ], + "sourcePath": "patterns/blue-green-deploy", + "repoPath": "delivery/patterns/blue-green-deploy-workflow" + }, + { + "slug": "bonus-allocation-workflow", + "title": "Bonus Allocation Workflow", + "description": "Annual bonus allocation workflow with budget pool distribution, performance-based calculation, manager calibration, executive approval, and payroll processing.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "bonus-allocation", + "annual-bonus", + "performance-bonus", + "budget-pool", + "calibration", + "payout" + ], + "sourcePath": "hr/bonus-allocation", + "repoPath": "uncategorized/hr/bonus-allocation-workflow" + }, + { + "slug": "budget-approval-workflow", + "title": "Budget Approval Workflow", + "description": "Corporate budget approval workflow with tiered approval routing based on amount thresholds (CFO < $100K, CEO $100K-$1M, Board > $1M), prior year comparison, and fund allocation.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "approval", + "secondaryUseCases": [], + "useCases": [ + "approval" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 3, + "tags": [ + "budget-approval", + "financial-planning", + "tiered-approval", + "cfo-approval", + "ceo-approval", + "board-approval", + "fund-allocation" + ], + "sourcePath": "finance/budget-approval", + "repoPath": "approval/finance/budget-approval-workflow" + }, + { + "slug": "cache-aside-workflow", + "title": "Cache Aside Workflow", + "description": "Cache-aside pattern with cache lookup, database fallback on miss, cache population, TTL-based expiration, and write-through invalidation.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "cache-aside", + "lazy-loading", + "cache-miss", + "cache-invalidation", + "redis", + "performance" + ], + "sourcePath": "patterns/cache-aside", + "repoPath": "uncategorized/patterns/cache-aside-workflow" + }, + { + "slug": "callback-pattern-workflow", + "title": "Callback Pattern Workflow", + "description": "This workflow models an async operation that notifies a callback when done.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "callback", + "pattern", + "patterns", + "decision", + "loop" + ], + "sourcePath": "patterns/callback-pattern", + "repoPath": "uncategorized/patterns/callback-pattern-workflow" + }, + { + "slug": "canary-deploy-workflow", + "title": "Canary Deploy Workflow", + "description": "Canary deployment pattern with gradual traffic shifting, real-time metrics monitoring, automatic rollback triggers, and progressive rollout to full production.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "incident", + "secondaryUseCases": [ + "delivery" + ], + "useCases": [ + "incident", + "delivery" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "canary-deployment", + "progressive-rollout", + "traffic-splitting", + "metrics-monitoring", + "gradual-release", + "feature-flags" + ], + "sourcePath": "patterns/canary-deploy", + "repoPath": "incident/patterns/canary-deploy-workflow" + }, + { + "slug": "candidate-rejection-workflow", + "title": "Candidate Rejection Workflow", + "description": "Candidate rejection workflow with stage-appropriate messaging, personalized rejection letters, talent pool consideration, ATS status update, and candidate experience feedback.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "candidate-rejection", + "hiring-decision", + "rejection-letter", + "talent-pool", + "candidate-experience", + "ats-update" + ], + "sourcePath": "hr/candidate-rejection", + "repoPath": "uncategorized/hr/candidate-rejection-workflow" + }, + { + "slug": "carrier-selection-workflow", + "title": "Carrier Selection Workflow", + "description": "Carrier selection workflow with rate shopping, transit time comparison, service level matching, carrier performance scoring, and optimal carrier assignment.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "carrier-selection", + "rate-shopping", + "transit-time", + "service-level", + "tms", + "freight-optimization" + ], + "sourcePath": "logistics/carrier-selection", + "repoPath": "uncategorized/logistics/carrier-selection-workflow" + }, + { + "slug": "cash-flow-forecast-workflow", + "title": "Cash Flow Forecast Workflow", + "description": "Cash flow forecasting workflow with AR/AP projections, working capital analysis, liquidity gap identification, and short-term financing recommendations.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "cash-flow-forecast", + "liquidity-planning", + "working-capital", + "ar-collections", + "ap-disbursements", + "treasury" + ], + "sourcePath": "finance/cash-flow-forecast", + "repoPath": "uncategorized/finance/cash-flow-forecast-workflow" + }, + { + "slug": "certificate-renewal-workflow", + "title": "Certificate Renewal Workflow", + "description": "SSL/TLS certificate renewal workflow with expiration monitoring, certificate request by type (DV/OV/EV), domain validation, deployment to load balancers, and health check verification with rollback.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "security", + "secondaryUseCases": [], + "useCases": [ + "security" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 3, + "tags": [ + "ssl-certificate", + "tls-renewal", + "lets-encrypt", + "certificate-authority", + "domain-validation", + "load-balancer", + "health-check" + ], + "sourcePath": "devops/certificate-renewal", + "repoPath": "security/devops/certificate-renewal-workflow" + }, + { + "slug": "chaos-engineering-workflow", + "title": "Chaos Engineering Workflow", + "description": "Chaos engineering workflow with hypothesis definition, steady-state monitoring, controlled fault injection, blast radius limitation, and resilience validation.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "chaos-engineering", + "fault-injection", + "resilience-testing", + "game-day", + "blast-radius", + "steady-state" + ], + "sourcePath": "devops/chaos-engineering", + "repoPath": "uncategorized/devops/chaos-engineering-workflow" + }, + { + "slug": "ci-cd-pipeline-workflow", + "title": "Ci Cd Pipeline Workflow", + "description": "Full CI/CD pipeline with code checkout, linting, unit tests, artifact building, staging deployment, smoke tests, production deployment, and automatic rollback on failure.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 4, + "numNodes": 22, + "numLanes": 3, + "tags": [ + "ci-cd", + "continuous-integration", + "continuous-deployment", + "github-actions", + "artifact-registry", + "staging", + "production", + "rollback" + ], + "sourcePath": "devops/ci-cd-pipeline", + "repoPath": "delivery/devops/ci-cd-pipeline-workflow" + }, + { + "slug": "circuit-breaker-workflow", + "title": "Circuit Breaker Workflow", + "description": "Circuit breaker resilience pattern with closed, open, and half-open states for protecting services from cascading failures with automatic recovery testing.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 3, + "tags": [ + "circuit-breaker", + "resilience", + "fault-tolerance", + "microservices", + "hystrix", + "half-open", + "fallback" + ], + "sourcePath": "patterns/circuit-breaker", + "repoPath": "mcp/patterns/circuit-breaker-workflow" + }, + { + "slug": "claim-check-workflow", + "title": "Claim Check Workflow", + "description": "This workflow models keeping large payloads external and only passing references.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "claim", + "check", + "patterns" + ], + "sourcePath": "patterns/claim-check", + "repoPath": "uncategorized/patterns/claim-check-workflow" + }, + { + "slug": "cohort-analysis-workflow", + "title": "Cohort Analysis Workflow", + "description": "Cohort analysis workflow with user segmentation by signup date, retention curve calculation, LTV projection, and behavioral pattern identification.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "cohort-analysis", + "retention-analysis", + "user-behavior", + "ltv", + "churn-prediction", + "analytics" + ], + "sourcePath": "business-operations/cohort-analysis", + "repoPath": "uncategorized/business-operations/cohort-analysis-workflow" + }, + { + "slug": "cold-chain-monitoring-workflow", + "title": "Cold Chain Monitoring Workflow", + "description": "Cold chain monitoring workflow with IoT temperature sensors, real-time alerts, excursion documentation, corrective action triggers, and compliance reporting.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "incident", + "secondaryUseCases": [], + "useCases": [ + "incident" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "cold-chain", + "temperature-monitoring", + "iot-sensors", + "excursion-alert", + "pharmaceutical", + "perishables" + ], + "sourcePath": "logistics/cold-chain-monitoring", + "repoPath": "incident/logistics/cold-chain-monitoring-workflow" + }, + { + "slug": "community-moderation-workflow", + "title": "Community Moderation Workflow", + "description": "Community content moderation workflow with AI auto-flagging, user reports, human review queue, action enforcement, and appeals handling.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "community-moderation", + "content-moderation", + "user-reports", + "trust-safety", + "ai-moderation", + "appeals" + ], + "sourcePath": "business-operations/community-moderation", + "repoPath": "uncategorized/business-operations/community-moderation-workflow" + }, + { + "slug": "compensation-transaction-workflow", + "title": "Compensation Transaction Workflow", + "description": "This workflow models rolling back work when a later step fails.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "compensation", + "transaction", + "patterns", + "decision", + "loop" + ], + "sourcePath": "patterns/compensation-transaction", + "repoPath": "uncategorized/patterns/compensation-transaction-workflow" + }, + { + "slug": "conflict-resolution-workflow", + "title": "Conflict Resolution Workflow", + "description": "Workplace conflict resolution workflow with complaint intake, HR investigation, mediation sessions, resolution documentation, and follow-up monitoring.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "billing", + "secondaryUseCases": [], + "useCases": [ + "billing" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "conflict-resolution", + "workplace-dispute", + "mediation", + "hr-investigation", + "employee-relations", + "grievance" + ], + "sourcePath": "hr/conflict-resolution", + "repoPath": "billing/hr/conflict-resolution-workflow" + }, + { + "slug": "consent-management-workflow", + "title": "Consent Management Workflow", + "description": "User consent management workflow with cookie banner, preference center, consent recording, downstream system sync, and audit trail.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "consent-management", + "gdpr", + "cookie-consent", + "privacy-preferences", + "opt-in-opt-out", + "compliance" + ], + "sourcePath": "business-operations/consent-management", + "repoPath": "compliance/business-operations/consent-management-workflow" + }, + { + "slug": "container-loading-workflow", + "title": "Container Loading Workflow", + "description": "Container loading workflow with load plan optimization, weight distribution, cube utilization maximization, seal application, and bill of lading generation.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "container-loading", + "load-planning", + "weight-distribution", + "cube-utilization", + "seal-verification", + "ocean-freight" + ], + "sourcePath": "logistics/container-loading", + "repoPath": "uncategorized/logistics/container-loading-workflow" + }, + { + "slug": "content-enricher-workflow", + "title": "Content Enricher Workflow", + "description": "This workflow models adding extra data from other sources.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "content", + "enricher", + "patterns", + "decision" + ], + "sourcePath": "patterns/content-enricher", + "repoPath": "uncategorized/patterns/content-enricher-workflow" + }, + { + "slug": "cost-center-workflow", + "title": "Cost Center Workflow", + "description": "This workflow models managing cost center budgets.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "cost", + "center", + "finance", + "decision" + ], + "sourcePath": "finance/cost-center", + "repoPath": "uncategorized/finance/cost-center-workflow" + }, + { + "slug": "cqrs-workflow", + "title": "Cqrs Workflow", + "description": "CQRS (Command Query Responsibility Segregation) pattern with separate command and query paths, domain event publishing, read model synchronization, and DTO transformation.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 19, + "numLanes": 4, + "tags": [ + "cqrs", + "command-query-separation", + "event-sourcing", + "read-model", + "write-model", + "domain-events", + "eventual-consistency" + ], + "sourcePath": "patterns/cqrs", + "repoPath": "uncategorized/patterns/cqrs-workflow" + }, + { + "slug": "credit-control-workflow", + "title": "Credit Control Workflow", + "description": "Customer credit control workflow with credit limit assessment, credit scoring, order hold management, collections escalation, and payment plan negotiation.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "credit-control", + "credit-limit", + "customer-credit", + "credit-scoring", + "collections", + "accounts-receivable" + ], + "sourcePath": "finance/credit-control", + "repoPath": "uncategorized/finance/credit-control-workflow" + }, + { + "slug": "cross-docking-workflow", + "title": "Cross Docking Workflow", + "description": "Cross-docking workflow with inbound scheduling, sortation by destination, outbound consolidation, and direct transfer without storage for just-in-time delivery.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "cross-docking", + "flow-through", + "dock-scheduling", + "sortation", + "consolidation", + "just-in-time" + ], + "sourcePath": "logistics/cross-docking", + "repoPath": "uncategorized/logistics/cross-docking-workflow" + }, + { + "slug": "crud-user-browser-server-workflow", + "title": "Crud User Browser Server Workflow", + "description": "This workflow models user creates, reads, updates, and deletes data through a browser and server.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "crud", + "user", + "browser", + "server", + "patterns" + ], + "sourcePath": "patterns/crud-user-browser-server", + "repoPath": "uncategorized/patterns/crud-user-browser-server-workflow" + }, + { + "slug": "customs-clearance-workflow", + "title": "Customs Clearance Workflow", + "description": "International customs clearance workflow with importer documentation, customs broker HS code classification, duty calculation, customs authority inspection, and clearance certificate issuance.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 19, + "numLanes": 3, + "tags": [ + "customs-clearance", + "international-trade", + "customs-broker", + "hs-codes", + "import-export", + "duties-taxes", + "inspection" + ], + "sourcePath": "logistics/customs-clearance", + "repoPath": "uncategorized/logistics/customs-clearance-workflow" + }, + { + "slug": "cycle-counting-workflow", + "title": "Cycle Counting Workflow", + "description": "Inventory cycle counting workflow with ABC classification, count scheduling, variance investigation, adjustment approval, and inventory accuracy tracking.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "cycle-counting", + "inventory-accuracy", + "abc-analysis", + "variance-investigation", + "perpetual-inventory", + "audit" + ], + "sourcePath": "logistics/cycle-counting", + "repoPath": "compliance/logistics/cycle-counting-workflow" + }, + { + "slug": "damaged-goods-workflow", + "title": "Damaged Goods Workflow", + "description": "Damaged goods processing workflow with damage documentation, carrier claim filing, disposition decision (salvage/dispose), inventory adjustment, and loss tracking.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "damaged-goods", + "damage-claim", + "inventory-write-off", + "carrier-claim", + "disposition", + "loss-prevention" + ], + "sourcePath": "logistics/damaged-goods", + "repoPath": "uncategorized/logistics/damaged-goods-workflow" + }, + { + "slug": "data-export-workflow", + "title": "Data Export Workflow", + "description": "User data export workflow with export request, async job processing, data aggregation, secure file generation, and download link delivery.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "data-export", + "data-portability", + "gdpr", + "bulk-export", + "async-job", + "download-link" + ], + "sourcePath": "business-operations/data-export", + "repoPath": "compliance/business-operations/data-export-workflow" + }, + { + "slug": "database-migration-workflow", + "title": "Database Migration Workflow", + "description": "Database schema migration workflow with CI testing, DBA review and approval, maintenance window scheduling, backup snapshots, migration execution, data integrity verification, and automatic rollback.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "delivery" + ], + "useCases": [ + "approval", + "delivery" + ], + "complexity": 4, + "numNodes": 20, + "numLanes": 4, + "tags": [ + "database-migration", + "schema-changes", + "flyway", + "liquibase", + "rollback", + "dba-approval", + "maintenance-window" + ], + "sourcePath": "devops/database-migration", + "repoPath": "approval/devops/database-migration-workflow" + }, + { + "slug": "dead-letter-queue-workflow", + "title": "Dead Letter Queue Workflow", + "description": "Dead letter queue pattern for handling failed messages with retry exhaustion detection, DLQ routing, manual inspection, and reprocessing capability.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "dead-letter-queue", + "dlq", + "message-retry", + "poison-message", + "error-handling", + "message-queue" + ], + "sourcePath": "patterns/dead-letter-queue", + "repoPath": "uncategorized/patterns/dead-letter-queue-workflow" + }, + { + "slug": "decision-diamond-workflow", + "title": "Decision Diamond Workflow", + "description": "This workflow models an if or then style branch for approval or rejection.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "decision", + "diamond", + "patterns" + ], + "sourcePath": "patterns/decision-diamond", + "repoPath": "uncategorized/patterns/decision-diamond-workflow" + }, + { + "slug": "delivery-confirmation-workflow", + "title": "Delivery Confirmation Workflow", + "description": "Delivery confirmation workflow with proof of delivery capture, signature collection, photo documentation, order status update, and customer notification.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "delivery-confirmation", + "pod", + "signature-capture", + "order-completion", + "customer-notification", + "tracking-update" + ], + "sourcePath": "logistics/delivery-confirmation", + "repoPath": "uncategorized/logistics/delivery-confirmation-workflow" + }, + { + "slug": "deployment-rollback-workflow", + "title": "Deployment Rollback Workflow", + "description": "Deployment rollback workflow with issue detection, rollback decision, previous version restoration, health verification, and post-mortem documentation.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "incident", + "secondaryUseCases": [ + "delivery" + ], + "useCases": [ + "incident", + "delivery" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "deployment-rollback", + "version-revert", + "incident-response", + "kubernetes", + "helm-rollback", + "service-recovery" + ], + "sourcePath": "devops/deployment-rollback", + "repoPath": "incident/devops/deployment-rollback-workflow" + }, + { + "slug": "diversity-initiative-workflow", + "title": "Diversity Initiative Workflow", + "description": "This workflow models promoting workplace diversity.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "diversity", + "initiative", + "hr" + ], + "sourcePath": "hr/diversity-initiative", + "repoPath": "uncategorized/hr/diversity-initiative-workflow" + }, + { + "slug": "dunning-flow-workflow", + "title": "Dunning Flow Workflow", + "description": "Dunning collection workflow with escalating reminder emails, grace period management, account suspension, and payment recovery tracking.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "billing", + "secondaryUseCases": [], + "useCases": [ + "billing" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "dunning-flow", + "collections", + "overdue-payment", + "payment-reminder", + "account-suspension", + "revenue-recovery" + ], + "sourcePath": "business-operations/dunning-flow", + "repoPath": "billing/business-operations/dunning-flow-workflow" + }, + { + "slug": "email-campaign-workflow", + "title": "Email Campaign Workflow", + "description": "Email marketing campaign workflow with audience segmentation, A/B testing, send scheduling, deliverability monitoring, and engagement analytics.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "email-campaign", + "marketing-automation", + "mailchimp", + "segmentation", + "a-b-testing", + "deliverability" + ], + "sourcePath": "business-operations/email-campaign", + "repoPath": "uncategorized/business-operations/email-campaign-workflow" + }, + { + "slug": "employee-engagement-workflow", + "title": "Employee Engagement Workflow", + "description": "This workflow models measuring and improving engagement.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "employee", + "engagement", + "hr", + "parallel" + ], + "sourcePath": "hr/employee-engagement", + "repoPath": "uncategorized/hr/employee-engagement-workflow" + }, + { + "slug": "enricher-workflow", + "title": "Enricher Workflow", + "description": "This workflow models adding metadata to messages before passing them on.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "enricher", + "patterns" + ], + "sourcePath": "patterns/enricher", + "repoPath": "uncategorized/patterns/enricher-workflow" + }, + { + "slug": "error-retry-loop-workflow", + "title": "Error Retry Loop Workflow", + "description": "This workflow models a failed operation that retries with backoff.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "error", + "retry", + "loop", + "patterns" + ], + "sourcePath": "patterns/error-retry-loop", + "repoPath": "uncategorized/patterns/error-retry-loop-workflow" + }, + { + "slug": "escalation-pattern-workflow", + "title": "Escalation Pattern Workflow", + "description": "This workflow models escalating issues to higher authority when needed.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "escalation", + "pattern", + "patterns" + ], + "sourcePath": "patterns/escalation-pattern", + "repoPath": "handoff/patterns/escalation-pattern-workflow" + }, + { + "slug": "event-driven-workflow", + "title": "Event Driven Workflow", + "description": "This workflow models reacting to incoming business events.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "event", + "driven", + "patterns" + ], + "sourcePath": "patterns/event-driven", + "repoPath": "uncategorized/patterns/event-driven-workflow" + }, + { + "slug": "event-sourcing-workflow", + "title": "Event Sourcing Workflow", + "description": "Event sourcing pattern with event capture, event store persistence, aggregate reconstruction, snapshot optimization, and temporal state queries.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "event-sourcing", + "event-store", + "aggregate", + "replay", + "audit-log", + "temporal-query" + ], + "sourcePath": "patterns/event-sourcing", + "repoPath": "compliance/patterns/event-sourcing-workflow" + }, + { + "slug": "expense-allocation-workflow", + "title": "Expense Allocation Workflow", + "description": "This workflow models allocating costs to departments.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "expense", + "allocation", + "finance" + ], + "sourcePath": "finance/expense-allocation", + "repoPath": "uncategorized/finance/expense-allocation-workflow" + }, + { + "slug": "expense-approval-workflow", + "title": "Expense Approval Workflow", + "description": "Employee expense approval workflow with receipt validation, policy compliance check, tiered approval based on amount, and reimbursement processing.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "compliance" + ], + "useCases": [ + "approval", + "compliance" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "expense-approval", + "travel-expenses", + "receipt-validation", + "policy-compliance", + "tiered-approval", + "reimbursement" + ], + "sourcePath": "hr/expense-approval", + "repoPath": "approval/hr/expense-approval-workflow" + }, + { + "slug": "expense-claim-workflow", + "title": "Expense Claim Workflow", + "description": "Employee expense reimbursement workflow with receipt submission, manager approval, finance review, policy compliance check, and direct deposit payment.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "approval", + "secondaryUseCases": [], + "useCases": [ + "approval" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "expense-reimbursement", + "employee-expenses", + "receipt-upload", + "manager-approval", + "finance-review", + "direct-deposit" + ], + "sourcePath": "finance/expense-claim", + "repoPath": "approval/finance/expense-claim-workflow" + }, + { + "slug": "fan-out-fan-in-workflow", + "title": "Fan Out Fan In Workflow", + "description": "Fan-out/fan-in pattern with work distribution to parallel workers, concurrent execution, result aggregation, and error handling for partial failures.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "ai-orchestration", + "secondaryUseCases": [], + "useCases": [ + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "fan-out-fan-in", + "scatter-gather", + "parallel-processing", + "aggregation", + "map-reduce", + "concurrency" + ], + "sourcePath": "patterns/fan-out-fan-in", + "repoPath": "ai-orchestration/patterns/fan-out-fan-in-workflow" + }, + { + "slug": "feature-toggle-workflow", + "title": "Feature Toggle Workflow", + "description": "Feature toggle pattern with flag configuration, user targeting rules, percentage rollouts, and instant kill-switch capability for production features.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "feature-toggle", + "feature-flags", + "dark-launch", + "a-b-testing", + "gradual-rollout", + "kill-switch" + ], + "sourcePath": "patterns/feature-toggle", + "repoPath": "uncategorized/patterns/feature-toggle-workflow" + }, + { + "slug": "filter-workflow", + "title": "Filter Workflow", + "description": "This workflow models removing items that do not meet criteria.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "filter", + "patterns", + "decision", + "loop" + ], + "sourcePath": "patterns/filter", + "repoPath": "uncategorized/patterns/filter-workflow" + }, + { + "slug": "financial-reporting-workflow", + "title": "Financial Reporting Workflow", + "description": "Financial reporting workflow with GAAP-compliant statement preparation, management review, audit committee approval, and SEC filing for public companies.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "financial-reporting", + "gaap-compliance", + "income-statement", + "balance-sheet", + "cash-flow-statement", + "sec-filing" + ], + "sourcePath": "finance/financial-reporting", + "repoPath": "compliance/finance/financial-reporting-workflow" + }, + { + "slug": "fixed-assets-workflow", + "title": "Fixed Assets Workflow", + "description": "Fixed asset management workflow with asset capitalization, depreciation scheduling, physical inventory verification, and asset disposal/retirement processing.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "fixed-assets", + "asset-tracking", + "depreciation", + "capitalization", + "asset-disposal", + "physical-inventory" + ], + "sourcePath": "finance/fixed-assets", + "repoPath": "uncategorized/finance/fixed-assets-workflow" + }, + { + "slug": "fleet-maintenance-workflow", + "title": "Fleet Maintenance Workflow", + "description": "Fleet maintenance workflow with preventive maintenance scheduling, vehicle inspection, work order creation, parts ordering, and DOT compliance tracking.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "fleet-maintenance", + "preventive-maintenance", + "vehicle-inspection", + "work-order", + "dot-compliance", + "telematics" + ], + "sourcePath": "logistics/fleet-maintenance", + "repoPath": "compliance/logistics/fleet-maintenance-workflow" + }, + { + "slug": "gdpr-deletion-workflow", + "title": "Gdpr Deletion Workflow", + "description": "GDPR data deletion workflow with identity verification, data inventory scan, PII removal across systems, backup purging, and deletion confirmation.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "gdpr-deletion", + "right-to-be-forgotten", + "data-privacy", + "pii-removal", + "compliance", + "dsar" + ], + "sourcePath": "business-operations/gdpr-deletion", + "repoPath": "compliance/business-operations/gdpr-deletion-workflow" + }, + { + "slug": "hazmat-handling-workflow", + "title": "Hazmat Handling Workflow", + "description": "Hazardous materials handling workflow with UN classification, SDS documentation, proper labeling, certified handler assignment, and emergency response procedures.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "incident", + "secondaryUseCases": [ + "compliance" + ], + "useCases": [ + "incident", + "compliance" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "hazmat-handling", + "dangerous-goods", + "un-classification", + "sds-documentation", + "dot-compliance", + "emergency-response" + ], + "sourcePath": "logistics/hazmat-handling", + "repoPath": "incident/logistics/hazmat-handling-workflow" + }, + { + "slug": "idempotent-consumer-workflow", + "title": "Idempotent Consumer Workflow", + "description": "This workflow models processing each message safely only once.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "idempotent", + "consumer", + "patterns" + ], + "sourcePath": "patterns/idempotent-consumer", + "repoPath": "uncategorized/patterns/idempotent-consumer-workflow" + }, + { + "slug": "in-app-message-workflow", + "title": "In App Message Workflow", + "description": "In-app messaging workflow with trigger conditions, audience targeting, message display, user interaction tracking, and conversion measurement.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "in-app-message", + "product-tours", + "tooltips", + "announcements", + "user-engagement", + "intercom" + ], + "sourcePath": "business-operations/in-app-message", + "repoPath": "uncategorized/business-operations/in-app-message-workflow" + }, + { + "slug": "incident-response-workflow", + "title": "Incident Response Workflow", + "description": "Production incident response workflow with severity-based routing, war room coordination, incident commander assignment, customer communication, root cause analysis, and postmortem scheduling.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "incident", + "secondaryUseCases": [], + "useCases": [ + "incident" + ], + "complexity": 5, + "numNodes": 23, + "numLanes": 4, + "tags": [ + "incident-management", + "on-call", + "pagerduty", + "war-room", + "severity-levels", + "postmortem", + "sre" + ], + "sourcePath": "devops/incident-response", + "repoPath": "incident/devops/incident-response-workflow" + }, + { + "slug": "infrastructure-provisioning-workflow", + "title": "Infrastructure Provisioning Workflow", + "description": "Infrastructure as Code provisioning workflow with Terraform plan, approval gates, state management, resource creation, and drift detection.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "infrastructure-provisioning", + "terraform", + "iac", + "cloud-resources", + "gitops", + "state-management" + ], + "sourcePath": "devops/infrastructure-provisioning", + "repoPath": "delivery/devops/infrastructure-provisioning-workflow" + }, + { + "slug": "insurance-claim-workflow", + "title": "Insurance Claim Workflow", + "description": "Insurance claim processing workflow with incident documentation, claim filing, adjuster assignment, damage assessment, and settlement negotiation.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "approval", + "secondaryUseCases": [], + "useCases": [ + "approval" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "insurance-claim", + "claim-filing", + "adjuster-review", + "settlement", + "property-damage", + "liability" + ], + "sourcePath": "finance/insurance-claim", + "repoPath": "approval/finance/insurance-claim-workflow" + }, + { + "slug": "internal-controls-workflow", + "title": "Internal Controls Workflow", + "description": "Internal controls testing workflow with risk assessment, control design evaluation, operating effectiveness testing, deficiency identification, and remediation tracking.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "internal-controls", + "sox-compliance", + "control-testing", + "segregation-of-duties", + "risk-assessment", + "remediation" + ], + "sourcePath": "finance/internal-controls", + "repoPath": "compliance/finance/internal-controls-workflow" + }, + { + "slug": "internship-program-workflow", + "title": "Internship Program Workflow", + "description": "This workflow models managing an internship program.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "internship", + "program", + "hr" + ], + "sourcePath": "hr/internship-program", + "repoPath": "uncategorized/hr/internship-program-workflow" + }, + { + "slug": "interview-process-workflow", + "title": "Interview Process Workflow", + "description": "Multi-stage interview process with resume screening, phone screen, technical interview, onsite panel, team consensus decision, and offer/rejection handling.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 22, + "numLanes": 3, + "tags": [ + "interview-process", + "hiring", + "phone-screen", + "technical-interview", + "onsite-panel", + "talent-acquisition", + "offer-management" + ], + "sourcePath": "hr/interview-process", + "repoPath": "uncategorized/hr/interview-process-workflow" + }, + { + "slug": "inventory-receipt-workflow", + "title": "Inventory Receipt Workflow", + "description": "Inventory receiving workflow with ASN verification, PO matching, quantity count, damage inspection, and WMS inventory update.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "inventory-receipt", + "goods-receiving", + "po-matching", + "asn-verification", + "dock-scheduling", + "wms" + ], + "sourcePath": "logistics/inventory-receipt", + "repoPath": "uncategorized/logistics/inventory-receipt-workflow" + }, + { + "slug": "invoice-processing-workflow", + "title": "Invoice Processing Workflow", + "description": "Accounts payable invoice automation with OCR data extraction, three-way PO matching, tiered approval workflow, and automated payment processing with GL updates.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "billing" + ], + "useCases": [ + "approval", + "billing" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 4, + "tags": [ + "accounts-payable", + "invoice-automation", + "ocr", + "po-matching", + "approval-workflow", + "payment-processing", + "three-way-match" + ], + "sourcePath": "finance/invoice-processing", + "repoPath": "approval/finance/invoice-processing-workflow" + }, + { + "slug": "job-posting-workflow", + "title": "Job Posting Workflow", + "description": "Job posting workflow with requisition approval, job description drafting, multi-channel posting (LinkedIn, Indeed, career sites), AI resume screening, and ATS candidate tracking.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 19, + "numLanes": 3, + "tags": [ + "job-posting", + "job-requisition", + "ats", + "linkedin", + "indeed", + "ai-screening", + "talent-acquisition" + ], + "sourcePath": "hr/job-posting", + "repoPath": "uncategorized/hr/job-posting-workflow" + }, + { + "slug": "kitting-process-workflow", + "title": "Kitting Process Workflow", + "description": "Kit assembly workflow with BOM explosion, component picking, assembly verification, kit labeling, and inventory conversion from components to finished kit.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "kitting-process", + "kit-assembly", + "bom", + "component-picking", + "value-added-services", + "bundling" + ], + "sourcePath": "logistics/kitting-process", + "repoPath": "uncategorized/logistics/kitting-process-workflow" + }, + { + "slug": "knowledge-base-workflow", + "title": "Knowledge Base Workflow", + "description": "Knowledge base management workflow with article creation, review approval, SEO optimization, version control, and search analytics tracking.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "support", + "secondaryUseCases": [], + "useCases": [ + "support" + ], + "complexity": 3, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "knowledge-base", + "help-center", + "documentation", + "self-service", + "article-management", + "zendesk" + ], + "sourcePath": "business-operations/knowledge-base", + "repoPath": "support/business-operations/knowledge-base-workflow" + }, + { + "slug": "last-mile-delivery-workflow", + "title": "Last Mile Delivery Workflow", + "description": "Last mile delivery workflow with route optimization, real-time GPS tracking, delivery attempt handling, proof of delivery capture, and customer notification.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "last-mile-delivery", + "route-optimization", + "proof-of-delivery", + "delivery-exception", + "customer-notification", + "gps-tracking" + ], + "sourcePath": "logistics/last-mile-delivery", + "repoPath": "uncategorized/logistics/last-mile-delivery-workflow" + }, + { + "slug": "load-testing-workflow", + "title": "Load Testing Workflow", + "description": "Load testing workflow with test scenario design, gradual ramp-up, performance metrics collection, bottleneck identification, and capacity recommendations.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "load-testing", + "performance-testing", + "stress-testing", + "k6", + "jmeter", + "capacity-planning" + ], + "sourcePath": "devops/load-testing", + "repoPath": "delivery/devops/load-testing-workflow" + }, + { + "slug": "materialized-view-workflow", + "title": "Materialized View Workflow", + "description": "This workflow models serving queries from a precomputed view.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "materialized", + "view", + "patterns", + "decision", + "loop" + ], + "sourcePath": "patterns/materialized-view", + "repoPath": "uncategorized/patterns/materialized-view-workflow" + }, + { + "slug": "message-queue-workflow", + "title": "Message Queue Workflow", + "description": "This workflow models asynchronous processing of work via a queue.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "message", + "queue", + "patterns", + "decision" + ], + "sourcePath": "patterns/message-queue", + "repoPath": "uncategorized/patterns/message-queue-workflow" + }, + { + "slug": "monitoring-alert-workflow", + "title": "Monitoring Alert Workflow", + "description": "Monitoring and alerting workflow with metric collection, threshold evaluation, alert routing, escalation policies, and incident creation.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "incident", + "secondaryUseCases": [], + "useCases": [ + "incident" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "monitoring-alerting", + "prometheus", + "pagerduty", + "threshold-alerts", + "anomaly-detection", + "on-call" + ], + "sourcePath": "devops/monitoring-alert", + "repoPath": "incident/devops/monitoring-alert-workflow" + }, + { + "slug": "monthly-close-workflow", + "title": "Monthly Close Workflow", + "description": "Corporate month-end financial close process including transaction posting, bank reconciliation, accruals, depreciation, trial balance validation, and financial statement generation.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 22, + "numLanes": 4, + "tags": [ + "monthly-close", + "financial-reporting", + "accounting", + "reconciliation", + "trial-balance", + "period-close" + ], + "sourcePath": "finance/monthly-close", + "repoPath": "uncategorized/finance/monthly-close-workflow" + }, + { + "slug": "nested-decisions-workflow", + "title": "Nested Decisions Workflow", + "description": "This workflow models multiple layers of decisions before completion.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "nested", + "decisions", + "patterns", + "decision", + "loop" + ], + "sourcePath": "patterns/nested-decisions", + "repoPath": "uncategorized/patterns/nested-decisions-workflow" + }, + { + "slug": "normalizer-workflow", + "title": "Normalizer Workflow", + "description": "This workflow models converting varied inputs to a standard format.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "normalizer", + "patterns" + ], + "sourcePath": "patterns/normalizer", + "repoPath": "uncategorized/patterns/normalizer-workflow" + }, + { + "slug": "notification-pattern-workflow", + "title": "Notification Pattern Workflow", + "description": "This workflow models sending alerts via multiple channels.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "notification", + "pattern", + "patterns" + ], + "sourcePath": "patterns/notification-pattern", + "repoPath": "uncategorized/patterns/notification-pattern-workflow" + }, + { + "slug": "oauth-flow-workflow", + "title": "Oauth Flow Workflow", + "description": "OAuth 2.0 authorization code flow with redirect handling, code exchange, token storage, refresh token rotation, and scope management.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "security" + ], + "useCases": [ + "approval", + "security" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "oauth-flow", + "oauth2", + "authorization-code", + "token-exchange", + "sso", + "third-party-auth" + ], + "sourcePath": "business-operations/oauth-flow", + "repoPath": "approval/business-operations/oauth-flow-workflow" + }, + { + "slug": "offboarding-workflow", + "title": "Offboarding Workflow", + "description": "Employee offboarding workflow with exit interview, knowledge transfer, asset collection, access revocation, final pay processing, and benefits continuation.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "handoff", + "secondaryUseCases": [ + "offboarding" + ], + "useCases": [ + "handoff", + "offboarding" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "employee-offboarding", + "exit-interview", + "access-revocation", + "asset-return", + "knowledge-transfer", + "final-paycheck" + ], + "sourcePath": "hr/offboarding", + "repoPath": "handoff/hr/offboarding-workflow" + }, + { + "slug": "on-call-rotation-workflow", + "title": "On Call Rotation Workflow", + "description": "On-call rotation workflow with schedule creation, shift handoffs, override management, escalation policies, and fair rotation distribution.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "handoff", + "secondaryUseCases": [ + "incident", + "security" + ], + "useCases": [ + "handoff", + "incident", + "security" + ], + "complexity": 3, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "on-call-rotation", + "incident-management", + "pagerduty", + "escalation", + "schedule-management", + "handoff" + ], + "sourcePath": "devops/on-call-rotation", + "repoPath": "handoff/devops/on-call-rotation-workflow" + }, + { + "slug": "onboarding-workflow", + "title": "Onboarding Workflow", + "description": "Complete employee onboarding workflow covering offer acceptance, HR record creation, benefits enrollment, background check verification, IT account provisioning, equipment setup, and first day orientation.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "onboarding", + "secondaryUseCases": [ + "delivery" + ], + "useCases": [ + "onboarding", + "delivery" + ], + "complexity": 4, + "numNodes": 20, + "numLanes": 3, + "tags": [ + "employee-onboarding", + "new-hire", + "hr-workflow", + "background-check", + "it-provisioning", + "benefits-enrollment" + ], + "sourcePath": "hr/onboarding", + "repoPath": "onboarding/hr/onboarding-workflow" + }, + { + "slug": "packing-process-workflow", + "title": "Packing Process Workflow", + "description": "Order packing workflow with carton selection, item verification, packing slip insertion, weight check, and package sealing for shipment.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "order-packing", + "box-selection", + "packing-slip", + "weight-verification", + "cartonization", + "fulfillment" + ], + "sourcePath": "logistics/packing-process", + "repoPath": "uncategorized/logistics/packing-process-workflow" + }, + { + "slug": "parallel-execution-workflow", + "title": "Parallel Execution Workflow", + "description": "This workflow models multiple tasks that run at the same time.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "parallel", + "execution", + "patterns", + "loop" + ], + "sourcePath": "patterns/parallel-execution", + "repoPath": "uncategorized/patterns/parallel-execution-workflow" + }, + { + "slug": "payment-failure-workflow", + "title": "Payment Failure Workflow", + "description": "Failed payment recovery workflow with smart retry scheduling, dunning email sequence, payment method update prompts, and involuntary churn prevention.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "billing", + "secondaryUseCases": [], + "useCases": [ + "billing" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "payment-failure", + "dunning", + "retry-logic", + "card-decline", + "revenue-recovery", + "stripe" + ], + "sourcePath": "business-operations/payment-failure", + "repoPath": "billing/business-operations/payment-failure-workflow" + }, + { + "slug": "payment-run-workflow", + "title": "Payment Run Workflow", + "description": "Accounts payable payment run workflow with batch creation, tiered approval (single/dual based on amount), ACH file generation, check printing, and vendor record updates.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "handoff", + "secondaryUseCases": [ + "approval", + "billing" + ], + "useCases": [ + "handoff", + "approval", + "billing" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 3, + "tags": [ + "payment-run", + "accounts-payable", + "ach-payments", + "check-run", + "dual-approval", + "bank-transfer", + "vendor-payments" + ], + "sourcePath": "finance/payment-run", + "repoPath": "handoff/finance/payment-run-workflow" + }, + { + "slug": "payroll-processing-workflow", + "title": "Payroll Processing Workflow", + "description": "Complete payroll processing workflow with timesheet collection, gross pay calculation, overtime, tax withholding (federal, state, FICA), benefits deductions, compliance validation, and ACH direct deposit.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 5, + "numNodes": 24, + "numLanes": 4, + "tags": [ + "payroll-processing", + "salary-calculation", + "tax-withholding", + "fica", + "ach-direct-deposit", + "benefits-deductions", + "compliance" + ], + "sourcePath": "finance/payroll-processing", + "repoPath": "compliance/finance/payroll-processing-workflow" + }, + { + "slug": "performance-review-workflow", + "title": "Performance Review Workflow", + "description": "Annual performance review workflow with self-assessment, manager evaluation, 360 feedback collection, calibration sessions, and merit increase recommendations.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "approval", + "secondaryUseCases": [], + "useCases": [ + "approval" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "performance-review", + "annual-evaluation", + "goal-setting", + "360-feedback", + "calibration", + "merit-increase" + ], + "sourcePath": "hr/performance-review", + "repoPath": "approval/hr/performance-review-workflow" + }, + { + "slug": "personalization-engine-workflow", + "title": "Personalization Engine Workflow", + "description": "Make.com automation scenario for real-time personalization using Segment events, ML recommendation API, and Braze campaign delivery across email and push channels.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 20, + "numLanes": 3, + "tags": [ + "make-com", + "personalization", + "segment", + "braze", + "ml-recommendations", + "content-delivery", + "marketing-automation" + ], + "sourcePath": "business-operations/personalization-engine", + "repoPath": "uncategorized/business-operations/personalization-engine-workflow" + }, + { + "slug": "picking-process-workflow", + "title": "Picking Process Workflow", + "description": "Warehouse order picking workflow with pick list generation, zone routing, batch picking optimization, barcode scanning verification, and pick completion confirmation.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "order-picking", + "warehouse-management", + "pick-list", + "batch-picking", + "wave-picking", + "wms" + ], + "sourcePath": "logistics/picking-process", + "repoPath": "uncategorized/logistics/picking-process-workflow" + }, + { + "slug": "plan-downgrade-workflow", + "title": "Plan Downgrade Workflow", + "description": "Subscription plan downgrade workflow with retention offer, feature restriction warning, data migration handling, and end-of-period scheduling.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "billing", + "secondaryUseCases": [ + "delivery" + ], + "useCases": [ + "billing", + "delivery" + ], + "complexity": 3, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "plan-downgrade", + "retention", + "feature-restriction", + "data-migration", + "churn-prevention", + "billing" + ], + "sourcePath": "business-operations/plan-downgrade", + "repoPath": "billing/business-operations/plan-downgrade-workflow" + }, + { + "slug": "plan-upgrade-workflow", + "title": "Plan Upgrade Workflow", + "description": "Subscription plan upgrade workflow with feature comparison, proration calculation, immediate feature unlock, and billing adjustment.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "billing", + "secondaryUseCases": [], + "useCases": [ + "billing" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "plan-upgrade", + "upsell", + "proration", + "feature-unlock", + "expansion-revenue", + "billing" + ], + "sourcePath": "business-operations/plan-upgrade", + "repoPath": "billing/business-operations/plan-upgrade-workflow" + }, + { + "slug": "polling-pattern-workflow", + "title": "Polling Pattern Workflow", + "description": "This workflow models periodically checking status until work is done.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "polling", + "pattern", + "patterns", + "loop" + ], + "sourcePath": "patterns/polling-pattern", + "repoPath": "uncategorized/patterns/polling-pattern-workflow" + }, + { + "slug": "process-manager-workflow", + "title": "Process Manager Workflow", + "description": "This workflow models orchestrating multiple services to complete a process.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "process", + "manager", + "patterns" + ], + "sourcePath": "patterns/process-manager", + "repoPath": "uncategorized/patterns/process-manager-workflow" + }, + { + "slug": "procurement-card-workflow", + "title": "Procurement Card Workflow", + "description": "This workflow models managing company credit cards.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "procurement", + "card", + "finance" + ], + "sourcePath": "finance/procurement-card", + "repoPath": "uncategorized/finance/procurement-card-workflow" + }, + { + "slug": "promotion-process-workflow", + "title": "Promotion Process Workflow", + "description": "Employee promotion workflow with performance validation, job level assessment, compensation adjustment, title change, and announcement coordination.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "promotion-process", + "career-advancement", + "job-leveling", + "title-change", + "compensation-adjustment", + "succession-planning" + ], + "sourcePath": "hr/promotion-process", + "repoPath": "uncategorized/hr/promotion-process-workflow" + }, + { + "slug": "pto-request-workflow", + "title": "Pto Request Workflow", + "description": "PTO request workflow with balance verification, manager approval, calendar blocking, and team coverage check before approval.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "approval", + "secondaryUseCases": [], + "useCases": [ + "approval" + ], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "pto-request", + "time-off", + "vacation", + "leave-management", + "manager-approval", + "accrual-balance" + ], + "sourcePath": "hr/pto-request", + "repoPath": "approval/hr/pto-request-workflow" + }, + { + "slug": "pub-sub-workflow", + "title": "Pub Sub Workflow", + "description": "This workflow models one publisher notifying many subscribers of events.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "pub", + "sub", + "patterns" + ], + "sourcePath": "patterns/pub-sub", + "repoPath": "uncategorized/patterns/pub-sub-workflow" + }, + { + "slug": "purchase-order-workflow", + "title": "Purchase Order Workflow", + "description": "Procurement purchase order workflow with requisition creation, budget validation, vendor sourcing, competitive bidding, and tiered approval routing based on amount thresholds.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "approval", + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 22, + "numLanes": 3, + "tags": [ + "purchase-order", + "procurement", + "requisition", + "vendor-sourcing", + "competitive-bidding", + "tiered-approval", + "budget-validation" + ], + "sourcePath": "finance/purchase-order", + "repoPath": "approval/finance/purchase-order-workflow" + }, + { + "slug": "push-notification-workflow", + "title": "Push Notification Workflow", + "description": "Mobile push notification workflow with audience targeting, platform routing (iOS/Android), delivery tracking, and engagement analytics.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "push-notification", + "mobile-engagement", + "firebase-fcm", + "apns", + "segmentation", + "deep-linking" + ], + "sourcePath": "business-operations/push-notification", + "repoPath": "uncategorized/business-operations/push-notification-workflow" + }, + { + "slug": "put-away-process-workflow", + "title": "Put Away Process Workflow", + "description": "Warehouse put-away workflow with location assignment, slotting optimization, forklift routing, barcode confirmation, and WMS location update.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "put-away", + "warehouse-storage", + "location-assignment", + "slotting", + "wms", + "inventory-placement" + ], + "sourcePath": "logistics/put-away-process", + "repoPath": "uncategorized/logistics/put-away-process-workflow" + }, + { + "slug": "quality-inspection-workflow", + "title": "Quality Inspection Workflow", + "description": "Incoming quality inspection workflow with AQL sampling, defect classification, hold/release decision, supplier notification, and quality metrics tracking.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "quality-inspection", + "incoming-inspection", + "aql-sampling", + "defect-tracking", + "supplier-quality", + "hold-release" + ], + "sourcePath": "logistics/quality-inspection", + "repoPath": "uncategorized/logistics/quality-inspection-workflow" + }, + { + "slug": "rate-limiter-workflow", + "title": "Rate Limiter Workflow", + "description": "This workflow models preventing too many requests from being processed.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "rate", + "limiter", + "patterns" + ], + "sourcePath": "patterns/rate-limiter", + "repoPath": "uncategorized/patterns/rate-limiter-workflow" + }, + { + "slug": "reference-check-workflow", + "title": "Reference Check Workflow", + "description": "Professional reference check workflow with reference collection, outreach scheduling, structured interview questions, feedback documentation, and hiring recommendation.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "reference-check", + "employment-verification", + "professional-references", + "hiring-decision", + "candidate-vetting", + "feedback-collection" + ], + "sourcePath": "hr/reference-check", + "repoPath": "uncategorized/hr/reference-check-workflow" + }, + { + "slug": "referral-program-workflow", + "title": "Referral Program Workflow", + "description": "Customer referral program workflow with unique link generation, referral tracking, conversion validation, and dual-sided reward fulfillment.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "referral-program", + "viral-growth", + "referral-tracking", + "reward-fulfillment", + "affiliate", + "word-of-mouth" + ], + "sourcePath": "business-operations/referral-program", + "repoPath": "uncategorized/business-operations/referral-program-workflow" + }, + { + "slug": "relocation-assistance-workflow", + "title": "Relocation Assistance Workflow", + "description": "This workflow models helping employees relocate.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "relocation", + "assistance", + "hr", + "decision" + ], + "sourcePath": "hr/relocation-assistance", + "repoPath": "uncategorized/hr/relocation-assistance-workflow" + }, + { + "slug": "reorder-process-workflow", + "title": "Reorder Process Workflow", + "description": "Inventory reorder workflow with reorder point monitoring, economic order quantity calculation, safety stock consideration, and automatic purchase requisition generation.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "reorder-process", + "reorder-point", + "safety-stock", + "eoq", + "demand-planning", + "auto-replenishment" + ], + "sourcePath": "logistics/reorder-process", + "repoPath": "uncategorized/logistics/reorder-process-workflow" + }, + { + "slug": "request-reply-workflow", + "title": "Request Reply Workflow", + "description": "This workflow models a synchronous request that waits for a reply.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "request", + "reply", + "patterns" + ], + "sourcePath": "patterns/request-reply", + "repoPath": "uncategorized/patterns/request-reply-workflow" + }, + { + "slug": "retry-with-backoff-workflow", + "title": "Retry With Backoff Workflow", + "description": "Exponential backoff retry pattern for API calls with configurable retry limits, delay calculation, retryable error detection, and graceful degradation on permanent failures.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 20, + "numLanes": 3, + "tags": [ + "retry-pattern", + "exponential-backoff", + "fault-tolerance", + "api-resilience", + "transient-errors", + "http-retry", + "jitter" + ], + "sourcePath": "patterns/retry-with-backoff", + "repoPath": "uncategorized/patterns/retry-with-backoff-workflow" + }, + { + "slug": "returns-processing-workflow", + "title": "Returns Processing Workflow", + "description": "Customer returns processing workflow with RMA generation, return receipt, quality inspection, disposition decision, and refund or exchange processing.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "billing", + "secondaryUseCases": [], + "useCases": [ + "billing" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "returns-processing", + "rma", + "refund", + "restocking", + "quality-inspection", + "reverse-logistics" + ], + "sourcePath": "logistics/returns-processing", + "repoPath": "billing/logistics/returns-processing-workflow" + }, + { + "slug": "reverse-logistics-workflow", + "title": "Reverse Logistics Workflow", + "description": "Reverse logistics workflow with return authorization, product grading, refurbishment decision, recycling coordination, and secondary market disposition.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "reverse-logistics", + "product-returns", + "refurbishment", + "recycling", + "disposition", + "sustainability" + ], + "sourcePath": "logistics/reverse-logistics", + "repoPath": "uncategorized/logistics/reverse-logistics-workflow" + }, + { + "slug": "review-collection-workflow", + "title": "Review Collection Workflow", + "description": "Customer review collection workflow with post-purchase trigger, review request email, rating submission, moderation, and public display.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "approval", + "secondaryUseCases": [], + "useCases": [ + "approval" + ], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "review-collection", + "customer-feedback", + "nps", + "ratings", + "social-proof", + "testimonials" + ], + "sourcePath": "business-operations/review-collection", + "repoPath": "approval/business-operations/review-collection-workflow" + }, + { + "slug": "router-workflow", + "title": "Router Workflow", + "description": "This workflow models routing messages based on their content.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "router", + "patterns", + "decision" + ], + "sourcePath": "patterns/router", + "repoPath": "uncategorized/patterns/router-workflow" + }, + { + "slug": "routing-slip-workflow", + "title": "Routing Slip Workflow", + "description": "This workflow models having messages carry their own routing instructions.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "routing", + "slip", + "patterns" + ], + "sourcePath": "patterns/routing-slip", + "repoPath": "handoff/patterns/routing-slip-workflow" + }, + { + "slug": "saga-pattern-workflow", + "title": "Saga Pattern Workflow", + "description": "Saga orchestration pattern for distributed transactions across Order, Payment, and Shipping services with automatic compensation rollback on failures.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "delivery", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "delivery", + "ai-orchestration" + ], + "complexity": 5, + "numNodes": 20, + "numLanes": 4, + "tags": [ + "saga-pattern", + "distributed-transactions", + "microservices", + "compensation", + "orchestration", + "eventual-consistency", + "rollback" + ], + "sourcePath": "patterns/saga-pattern", + "repoPath": "delivery/patterns/saga-pattern-workflow" + }, + { + "slug": "salary-increase-workflow", + "title": "Salary Increase Workflow", + "description": "Salary increase workflow with market analysis, comp ratio review, budget validation, tiered approval based on increase percentage, and payroll system update.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "approval", + "secondaryUseCases": [], + "useCases": [ + "approval" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "salary-increase", + "compensation", + "merit-raise", + "market-adjustment", + "budget-approval", + "comp-ratio" + ], + "sourcePath": "hr/salary-increase", + "repoPath": "approval/hr/salary-increase-workflow" + }, + { + "slug": "search-optimization-workflow", + "title": "Search Optimization Workflow", + "description": "Search optimization workflow with query analysis, relevance tuning, synonym management, click-through tracking, and A/B testing of ranking algorithms.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "search-optimization", + "elasticsearch", + "relevance-tuning", + "query-analysis", + "algolia", + "search-analytics" + ], + "sourcePath": "business-operations/search-optimization", + "repoPath": "uncategorized/business-operations/search-optimization-workflow" + }, + { + "slug": "secret-rotation-workflow", + "title": "Secret Rotation Workflow", + "description": "Automated secret rotation workflow with HashiCorp Vault for API keys, database passwords, and certificates including Kubernetes secret updates and rolling service restarts.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "security", + "secondaryUseCases": [], + "useCases": [ + "security" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 3, + "tags": [ + "secret-rotation", + "vault", + "kubernetes-secrets", + "api-keys", + "database-passwords", + "certificates", + "security" + ], + "sourcePath": "devops/secret-rotation", + "repoPath": "security/devops/secret-rotation-workflow" + }, + { + "slug": "security-scan-workflow", + "title": "Security Scan Workflow", + "description": "Security scanning workflow with SAST, DAST, dependency vulnerability scanning, finding triage, and remediation tracking in CI/CD pipeline.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "security", + "secondaryUseCases": [], + "useCases": [ + "security" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "security-scanning", + "sast", + "dast", + "dependency-check", + "snyk", + "devsecops" + ], + "sourcePath": "devops/security-scan", + "repoPath": "security/devops/security-scan-workflow" + }, + { + "slug": "shipping-process-workflow", + "title": "Shipping Process Workflow", + "description": "Order shipping workflow with carrier selection, rate shopping, label generation, tracking number assignment, and dispatch confirmation.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "security", + "secondaryUseCases": [], + "useCases": [ + "security" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "shipping-process", + "order-fulfillment", + "carrier-selection", + "label-generation", + "tracking-number", + "dispatch" + ], + "sourcePath": "logistics/shipping-process", + "repoPath": "security/logistics/shipping-process-workflow" + }, + { + "slug": "sms-verification-workflow", + "title": "Sms Verification Workflow", + "description": "SMS phone verification workflow with OTP generation, rate limiting, code validation, retry handling, and verification status tracking.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "security", + "secondaryUseCases": [], + "useCases": [ + "security" + ], + "complexity": 3, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "sms-verification", + "otp", + "twilio", + "phone-verification", + "2fa", + "fraud-prevention" + ], + "sourcePath": "business-operations/sms-verification", + "repoPath": "security/business-operations/sms-verification-workflow" + }, + { + "slug": "snapshot-pattern-workflow", + "title": "Snapshot Pattern Workflow", + "description": "This workflow models taking periodic snapshots of important state.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "snapshot", + "pattern", + "patterns", + "decision", + "loop" + ], + "sourcePath": "patterns/snapshot-pattern", + "repoPath": "uncategorized/patterns/snapshot-pattern-workflow" + }, + { + "slug": "state-machine-workflow", + "title": "State Machine Workflow", + "description": "This workflow models tracking object state changes over time.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "state", + "machine", + "patterns", + "parallel" + ], + "sourcePath": "patterns/state-machine", + "repoPath": "uncategorized/patterns/state-machine-workflow" + }, + { + "slug": "stock-transfer-workflow", + "title": "Stock Transfer Workflow", + "description": "Internal stock transfer workflow with transfer request, source location pick, destination put-away, and inventory record updates across locations.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "stock-transfer", + "inventory-movement", + "location-transfer", + "bin-to-bin", + "wms", + "inventory-rebalancing" + ], + "sourcePath": "logistics/stock-transfer", + "repoPath": "handoff/logistics/stock-transfer-workflow" + }, + { + "slug": "strangler-fig-workflow", + "title": "Strangler Fig Workflow", + "description": "This workflow models gradually replacing an old system with a new one.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "strangler", + "fig", + "patterns", + "decision" + ], + "sourcePath": "patterns/strangler-fig", + "repoPath": "uncategorized/patterns/strangler-fig-workflow" + }, + { + "slug": "subscription-lifecycle-workflow", + "title": "Subscription Lifecycle Workflow", + "description": "SaaS subscription lifecycle workflow with trial signup, conversion nurturing, payment processing, renewal management, and churn prevention campaigns.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "billing", + "secondaryUseCases": [], + "useCases": [ + "billing" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "subscription-lifecycle", + "saas", + "trial-conversion", + "renewal", + "churn-prevention", + "stripe" + ], + "sourcePath": "business-operations/subscription-lifecycle", + "repoPath": "billing/business-operations/subscription-lifecycle-workflow" + }, + { + "slug": "support-ticket-workflow", + "title": "Support Ticket Workflow", + "description": "Customer support ticket workflow with auto-categorization, SLA tracking, agent assignment, escalation rules, and satisfaction survey.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "handoff", + "secondaryUseCases": [ + "support" + ], + "useCases": [ + "handoff", + "support" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "support-ticket", + "helpdesk", + "zendesk", + "sla", + "ticket-routing", + "customer-service" + ], + "sourcePath": "business-operations/support-ticket", + "repoPath": "handoff/business-operations/support-ticket-workflow" + }, + { + "slug": "tax-filing-workflow", + "title": "Tax Filing Workflow", + "description": "Corporate tax filing workflow with taxable income calculation, deductions, tax credits, variance review, and electronic or paper filing to IRS with receipt confirmation.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 3, + "tags": [ + "tax-filing", + "corporate-tax", + "tax-calculation", + "irs-efile", + "tax-credits", + "deductions", + "compliance" + ], + "sourcePath": "finance/tax-filing", + "repoPath": "compliance/finance/tax-filing-workflow" + }, + { + "slug": "termination-process-workflow", + "title": "Termination Process Workflow", + "description": "Employee termination workflow handling voluntary and involuntary separations with legal review, separation agreements, final pay calculation, COBRA notices, and severance processing.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "offboarding" + ], + "useCases": [ + "approval", + "offboarding" + ], + "complexity": 4, + "numNodes": 20, + "numLanes": 3, + "tags": [ + "employee-termination", + "offboarding", + "separation-agreement", + "final-pay", + "cobra", + "severance", + "legal-review" + ], + "sourcePath": "hr/termination-process", + "repoPath": "approval/hr/termination-process-workflow" + }, + { + "slug": "timeout-pattern-workflow", + "title": "Timeout Pattern Workflow", + "description": "This workflow models an operation that times out after a delay.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "timeout", + "pattern", + "patterns" + ], + "sourcePath": "patterns/timeout-pattern", + "repoPath": "uncategorized/patterns/timeout-pattern-workflow" + }, + { + "slug": "training-enrollment-workflow", + "title": "Training Enrollment Workflow", + "description": "Training enrollment workflow with course catalog browsing, manager approval, LMS registration, completion tracking, and certification management.", + "kind": "workflow", + "sourceDomain": "hr", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "training-enrollment", + "learning-management", + "lms", + "professional-development", + "compliance-training", + "certification" + ], + "sourcePath": "hr/training-enrollment", + "repoPath": "compliance/hr/training-enrollment-workflow" + }, + { + "slug": "transactional-outbox-workflow", + "title": "Transactional Outbox Workflow", + "description": "This workflow models writing data and publishing messages in one transaction.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 13, + "numLanes": 4, + "tags": [ + "transactional", + "outbox", + "patterns", + "parallel" + ], + "sourcePath": "patterns/transactional-outbox", + "repoPath": "uncategorized/patterns/transactional-outbox-workflow" + }, + { + "slug": "transform-workflow", + "title": "Transform Workflow", + "description": "This workflow models converting messages into a new shape.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "transform", + "patterns" + ], + "sourcePath": "patterns/transform", + "repoPath": "uncategorized/patterns/transform-workflow" + }, + { + "slug": "treasury-management-workflow", + "title": "Treasury Management Workflow", + "description": "Corporate treasury management workflow with cash pooling, FX exposure hedging, short-term investment decisions, and bank relationship management.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "treasury-management", + "cash-pooling", + "fx-hedging", + "investment-portfolio", + "bank-relationships", + "liquidity" + ], + "sourcePath": "finance/treasury-management", + "repoPath": "uncategorized/finance/treasury-management-workflow" + }, + { + "slug": "two-factor-setup-workflow", + "title": "Two Factor Setup Workflow", + "description": "Two-factor authentication setup workflow with method selection (TOTP/SMS), QR code generation, backup codes, and verification confirmation.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "onboarding", + "secondaryUseCases": [ + "security" + ], + "useCases": [ + "onboarding", + "security" + ], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "two-factor-auth", + "mfa", + "totp", + "authenticator-app", + "security", + "account-protection" + ], + "sourcePath": "business-operations/two-factor-setup", + "repoPath": "onboarding/business-operations/two-factor-setup-workflow" + }, + { + "slug": "user-onboarding-workflow", + "title": "User Onboarding Workflow", + "description": "New user onboarding workflow with welcome email, profile setup, product tour, first action prompt, and activation milestone tracking.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "onboarding", + "secondaryUseCases": [], + "useCases": [ + "onboarding" + ], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "user-onboarding", + "activation", + "product-tour", + "welcome-email", + "first-time-user", + "time-to-value" + ], + "sourcePath": "business-operations/user-onboarding", + "repoPath": "onboarding/business-operations/user-onboarding-workflow" + }, + { + "slug": "user-segmentation-workflow", + "title": "User Segmentation Workflow", + "description": "User segmentation workflow with attribute collection, behavioral event tracking, segment rule definition, dynamic membership, and downstream sync.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "user-segmentation", + "audience-targeting", + "behavioral-cohorts", + "customer-segments", + "segment", + "marketing-automation" + ], + "sourcePath": "business-operations/user-segmentation", + "repoPath": "uncategorized/business-operations/user-segmentation-workflow" + }, + { + "slug": "validator-workflow", + "title": "Validator Workflow", + "description": "This workflow models checking that incoming data is valid.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "validator", + "patterns", + "parallel" + ], + "sourcePath": "patterns/validator", + "repoPath": "uncategorized/patterns/validator-workflow" + }, + { + "slug": "vendor-onboarding-workflow", + "title": "Vendor Onboarding Workflow", + "description": "Vendor onboarding workflow with application review, W-9/W-8BEN verification, insurance certificate validation, background checks, and compliance approval before vendor activation.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "onboarding", + "secondaryUseCases": [ + "billing", + "compliance" + ], + "useCases": [ + "onboarding", + "billing", + "compliance" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 3, + "tags": [ + "vendor-onboarding", + "supplier-management", + "w9-verification", + "insurance-compliance", + "background-check", + "payment-terms", + "procurement" + ], + "sourcePath": "finance/vendor-onboarding", + "repoPath": "onboarding/finance/vendor-onboarding-workflow" + }, + { + "slug": "vulnerability-patch-workflow", + "title": "Vulnerability Patch Workflow", + "description": "Security vulnerability patching workflow with CVE scanning, severity-based triage (critical/high/medium), patch testing, staging deployment, and production rollout with rollback capability.", + "kind": "workflow", + "sourceDomain": "devops", + "primaryUseCase": "security", + "secondaryUseCases": [ + "compliance", + "delivery" + ], + "useCases": [ + "security", + "compliance", + "delivery" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 3, + "tags": [ + "vulnerability-management", + "security-patching", + "cve-triage", + "cvss-scoring", + "patch-testing", + "rollback", + "compliance" + ], + "sourcePath": "devops/vulnerability-patch", + "repoPath": "security/devops/vulnerability-patch-workflow" + }, + { + "slug": "warehouse-transfer-workflow", + "title": "Warehouse Transfer Workflow", + "description": "Inter-warehouse transfer workflow with transfer order creation, shipping from source DC, in-transit tracking, and receiving at destination warehouse.", + "kind": "workflow", + "sourceDomain": "logistics", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "warehouse-transfer", + "inter-facility", + "transfer-order", + "in-transit-inventory", + "network-optimization", + "distribution" + ], + "sourcePath": "logistics/warehouse-transfer", + "repoPath": "handoff/logistics/warehouse-transfer-workflow" + }, + { + "slug": "webhook-integration-workflow", + "title": "Webhook Integration Workflow", + "description": "Webhook integration workflow with endpoint registration, payload signing, delivery attempt, retry with backoff, and delivery status tracking.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "webhook", + "event-driven", + "http-callback", + "integration", + "retry-logic", + "payload-signing" + ], + "sourcePath": "business-operations/webhook-integration", + "repoPath": "uncategorized/business-operations/webhook-integration-workflow" + }, + { + "slug": "webhook-pattern-workflow", + "title": "Webhook Pattern Workflow", + "description": "This workflow models an HTTP callback when an event occurs.", + "kind": "workflow", + "sourceDomain": "patterns", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "webhook", + "pattern", + "patterns", + "decision", + "loop" + ], + "sourcePath": "patterns/webhook-pattern", + "repoPath": "uncategorized/patterns/webhook-pattern-workflow" + }, + { + "slug": "webinar-registration-workflow", + "title": "Webinar Registration Workflow", + "description": "Webinar registration workflow with signup form, calendar invite, reminder email sequence, attendance tracking, and post-event follow-up.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "onboarding", + "secondaryUseCases": [], + "useCases": [ + "onboarding" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "webinar", + "event-registration", + "zoom", + "calendar-invite", + "reminder-sequence", + "lead-capture" + ], + "sourcePath": "business-operations/webinar-registration", + "repoPath": "onboarding/business-operations/webinar-registration-workflow" + }, + { + "slug": "yearly-audit-workflow", + "title": "Yearly Audit Workflow", + "description": "Annual financial audit workflow with external auditor engagement, document preparation, fieldwork coordination, findings remediation, and management letter response.", + "kind": "workflow", + "sourceDomain": "finance", + "primaryUseCase": "compliance", + "secondaryUseCases": [], + "useCases": [ + "compliance" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "annual-audit", + "external-auditors", + "sox-compliance", + "financial-statements", + "audit-findings", + "management-letter" + ], + "sourcePath": "finance/yearly-audit", + "repoPath": "compliance/finance/yearly-audit-workflow" + }, + { + "slug": "shopify-universal-commerce-protocol", + "title": "Shopify Universal Commerce Protocol", + "description": "End-to-end agentic commerce workflow showing how an AI assistant (ChatGPT) orchestrates product search, checkout, and payment through Shopify's Universal Commerce Protocol (UCP) gateway, enabling conversational shopping experiences.", + "kind": "workflow", + "sourceDomain": "business-operations", + "primaryUseCase": "billing", + "secondaryUseCases": [ + "agentic" + ], + "useCases": [ + "billing", + "agentic" + ], + "complexity": 4, + "numNodes": 47, + "numLanes": 5, + "tags": [ + "shopify", + "ucp", + "universal-commerce-protocol", + "agentic-commerce", + "ai-shopping", + "chatgpt", + "e-commerce", + "checkout", + "payment" + ], + "sourcePath": "business-operations/shopify-universal-commerce-protocol", + "repoPath": "billing/business-operations/shopify-universal-commerce-protocol" + }, + { + "slug": "microservices-api-gateway-architecture", + "title": "Microservices API Gateway Architecture", + "description": "A microservices API gateway architecture diagram showing request routing, JWT authentication, rate limiting, service discovery, and response aggregation across distributed backend services. This template models the entry point for all client traffic in a microservices ecosystem, enforcing security policies before requests reach internal services. Ideal for platform engineers designing scalable API infrastructure with centralized cross-cutting concerns.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "security", + "secondaryUseCases": [ + "mcp" + ], + "useCases": [ + "security", + "mcp" + ], + "complexity": 4, + "numNodes": 17, + "numLanes": 3, + "tags": [ + "microservices", + "api-gateway", + "jwt-authentication", + "rate-limiting", + "service-discovery", + "load-balancing", + "architecture-diagram", + "distributed-systems" + ], + "sourcePath": "", + "repoPath": "security/architecture/microservices-api-gateway-architecture" + }, + { + "slug": "microservices-service-mesh-architecture", + "title": "Microservices Service Mesh Architecture", + "description": "A service mesh architecture diagram with Istio or Linkerd sidecar proxies handling mTLS encryption, traffic policies, circuit breaking, and distributed tracing across microservices. This template visualizes how a service mesh abstracts networking concerns away from application code, enabling zero-trust communication between services. Essential for teams adopting service mesh infrastructure to improve observability and security.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 3, + "tags": [ + "service-mesh", + "istio", + "linkerd", + "mtls", + "sidecar-proxy", + "distributed-tracing", + "traffic-management", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "mcp/architecture/microservices-service-mesh-architecture" + }, + { + "slug": "microservices-database-per-service-architecture", + "title": "Microservices Database-Per-Service Architecture", + "description": "A database-per-service architecture diagram where each microservice owns its dedicated data store, with event-driven synchronization via Kafka for cross-service data consistency. This template demonstrates the core microservices data isolation principle, showing how PostgreSQL and MongoDB coexist in a polyglot persistence strategy. Critical for architects enforcing service autonomy while maintaining eventual consistency.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 16, + "numLanes": 4, + "tags": [ + "database-per-service", + "polyglot-persistence", + "microservices", + "kafka", + "event-driven", + "data-isolation", + "eventual-consistency", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/microservices-database-per-service-architecture" + }, + { + "slug": "microservices-decomposition-by-business-capability", + "title": "Microservices Decomposition by Business Capability", + "description": "A microservices decomposition architecture diagram organized by business capabilities: Identity, Product Catalog, Pricing, and Order Fulfillment, each with independent data stores and APIs. This template shows how to break a monolith into services aligned with business domains, using a Backend-for-Frontend (BFF) pattern for client-specific aggregation. Useful for architects planning domain-driven microservice boundaries.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 17, + "numLanes": 5, + "tags": [ + "microservices-decomposition", + "business-capability", + "bff", + "domain-driven-design", + "service-boundaries", + "monolith-to-microservices", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/microservices-decomposition-by-business-capability" + }, + { + "slug": "microservices-strangler-fig-migration", + "title": "Microservices Strangler Fig Migration Architecture", + "description": "A strangler fig migration architecture diagram showing the incremental replacement of a legacy monolith with new microservices, using a routing layer to split traffic between old and new systems. This template models the proven migration strategy where new features are built as microservices while legacy endpoints are gradually retired. Essential for teams modernizing legacy systems without risky big-bang rewrites.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 4, + "numNodes": 16, + "numLanes": 4, + "tags": [ + "strangler-fig", + "legacy-migration", + "monolith-decomposition", + "anti-corruption-layer", + "incremental-migration", + "modernization", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/microservices-strangler-fig-migration" + }, + { + "slug": "microservices-service-discovery-architecture", + "title": "Microservices Service Discovery Architecture", + "description": "A service discovery architecture diagram with Consul or Eureka registry, client-side load balancing, health check heartbeats, and automatic instance registration and deregistration. This template visualizes how microservices dynamically locate each other without hardcoded endpoints, enabling elastic scaling and self-healing infrastructure. Key for platform teams building resilient service-to-service communication.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 3, + "numNodes": 16, + "numLanes": 3, + "tags": [ + "service-discovery", + "consul", + "eureka", + "health-check", + "client-side-load-balancing", + "service-registry", + "dynamic-routing", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "handoff/architecture/microservices-service-discovery-architecture" + }, + { + "slug": "microservices-sidecar-pattern-architecture", + "title": "Microservices Sidecar Pattern Architecture", + "description": "A sidecar pattern architecture diagram showing Envoy proxy, log collector, and config watcher sidecars running alongside application containers in a Kubernetes pod, with a control plane managing configuration. This template demonstrates how auxiliary concerns like logging, monitoring, and configuration are deployed as co-located containers. Foundational for teams adopting cloud-native container orchestration patterns.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 4, + "numNodes": 13, + "numLanes": 3, + "tags": [ + "sidecar-pattern", + "envoy-proxy", + "kubernetes", + "container-pattern", + "observability", + "control-plane", + "cloud-native", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "mcp/architecture/microservices-sidecar-pattern-architecture" + }, + { + "slug": "microservices-backend-for-frontend-architecture", + "title": "Microservices Backend-for-Frontend (BFF) Architecture", + "description": "A Backend-for-Frontend architecture diagram with separate BFF layers for web and mobile clients, each optimizing API responses for their specific platform while sharing common backend microservices. This template shows how to avoid one-size-fits-all APIs by tailoring data aggregation and payload optimization per client type. Recommended for teams serving multiple frontend platforms from a shared microservices backend.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 12, + "numLanes": 3, + "tags": [ + "backend-for-frontend", + "bff-pattern", + "mobile-api", + "web-api", + "api-aggregation", + "payload-optimization", + "microservices", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/microservices-backend-for-frontend-architecture" + }, + { + "slug": "event-driven-publish-subscribe-architecture", + "title": "Event-Driven Publish-Subscribe Architecture", + "description": "An event-driven publish-subscribe architecture diagram with Kafka or RabbitMQ message broker, event serialization, topic partitioning, fan-out delivery to multiple consumers, and dead letter queue error handling. This template models the foundational async messaging pattern where producers and consumers are fully decoupled through a message broker. Essential for architects building loosely coupled, scalable event-driven systems.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 17, + "numLanes": 3, + "tags": [ + "publish-subscribe", + "event-driven", + "kafka", + "rabbitmq", + "message-broker", + "fan-out", + "dead-letter-queue", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/event-driven-publish-subscribe-architecture" + }, + { + "slug": "event-driven-event-sourcing-architecture", + "title": "Event-Driven Event Sourcing Architecture", + "description": "An event sourcing architecture diagram where all state changes are stored as an immutable sequence of domain events, with read projections built from the event stream and snapshot optimization for fast aggregate loading. This template shows how event sourcing eliminates data loss by preserving the complete history of every state transition. Critical for systems requiring full audit trails, temporal queries, and event replay capabilities.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "event-sourcing", + "immutable-events", + "event-store", + "projections", + "snapshot", + "aggregate", + "temporal-query", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/event-driven-event-sourcing-architecture" + }, + { + "slug": "event-driven-cqrs-with-event-store-architecture", + "title": "Event-Driven CQRS with Event Store Architecture", + "description": "A CQRS architecture diagram combining separate command and query APIs with an event bus for asynchronous read model synchronization, including projectors that build denormalized views from domain events. This template demonstrates the full CQRS+ES stack where writes go through domain validation and reads are served from optimized materialized views. Ideal for high-throughput systems where read and write workloads have fundamentally different scaling requirements.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "cqrs", + "event-store", + "command-query-separation", + "read-model", + "write-model", + "projector", + "eventual-consistency", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/event-driven-cqrs-with-event-store-architecture" + }, + { + "slug": "event-driven-choreography-architecture", + "title": "Event-Driven Choreography Architecture", + "description": "An event-driven choreography architecture diagram where microservices coordinate through events without a central orchestrator, with Order, Payment, Inventory, and Shipping services reacting to each other's domain events. This template models the decentralized coordination pattern where each service knows only its own responsibilities and publishes events for others to consume. Best for teams favoring autonomous services over centralized workflow control.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 19, + "numLanes": 5, + "tags": [ + "choreography", + "event-driven", + "decentralized-coordination", + "domain-events", + "microservices", + "autonomous-services", + "pub-sub", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/event-driven-choreography-architecture" + }, + { + "slug": "event-driven-event-streaming-pipeline-architecture", + "title": "Event-Driven Streaming Pipeline Architecture", + "description": "A real-time event streaming pipeline architecture diagram with IoT sensors, application logs, and clickstream data flowing through Kafka into Apache Flink for window aggregation, anomaly detection, and multi-sink output to data lakes and dashboards. This template visualizes end-to-end stream processing from ingestion through transformation to storage and alerting. Essential for data engineers building real-time analytics and monitoring platforms.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "event-streaming", + "kafka", + "apache-flink", + "stream-processing", + "real-time-analytics", + "iot", + "data-pipeline", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/event-driven-event-streaming-pipeline-architecture" + }, + { + "slug": "event-driven-domain-events-architecture", + "title": "Event-Driven Domain Events Architecture", + "description": "A domain events architecture diagram showing how aggregate roots raise domain events that are dispatched both in-process to local handlers and cross-boundary to integration event consumers in other bounded contexts. This template models the DDD event pattern where domain logic triggers side effects through a clean event dispatcher, maintaining separation between domain and infrastructure concerns. Key for teams implementing Domain-Driven Design with event-based integration.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "security", + "secondaryUseCases": [], + "useCases": [ + "security" + ], + "complexity": 4, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "domain-events", + "ddd", + "aggregate-root", + "bounded-context", + "event-dispatcher", + "integration-events", + "domain-driven-design", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "security/architecture/event-driven-domain-events-architecture" + }, + { + "slug": "event-driven-cdc-change-data-capture-architecture", + "title": "Event-Driven CDC (Change Data Capture) Architecture", + "description": "A Change Data Capture architecture diagram using Debezium to tail database transaction logs and publish change events to Kafka, feeding downstream consumers that update search indexes, invalidate caches, load data warehouses, and write audit logs. This template shows how CDC eliminates dual-write problems by capturing changes at the database level without modifying application code. Critical for data synchronization across heterogeneous systems.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "change-data-capture", + "cdc", + "debezium", + "transaction-log", + "kafka-connect", + "data-synchronization", + "dual-write", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/event-driven-cdc-change-data-capture-architecture" + }, + { + "slug": "event-driven-dead-letter-queue-architecture", + "title": "Event-Driven Dead Letter Queue Architecture", + "description": "A dead letter queue architecture diagram with retry policies, exponential backoff, max retry thresholds, DLQ routing for failed messages, operations alerting, and manual reprocessing workflows. This template models the critical error handling pattern for asynchronous messaging systems, ensuring no message is silently lost when processing fails. Essential for building reliable event-driven systems with proper failure recovery mechanisms.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "incident", + "secondaryUseCases": [ + "compliance" + ], + "useCases": [ + "incident", + "compliance" + ], + "complexity": 3, + "numNodes": 16, + "numLanes": 3, + "tags": [ + "dead-letter-queue", + "dlq", + "retry-policy", + "message-processing", + "error-handling", + "operations-alerting", + "message-reliability", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "incident/architecture/event-driven-dead-letter-queue-architecture" + }, + { + "slug": "cqrs-read-write-separation-architecture", + "title": "CQRS Read-Write Separation Architecture", + "description": "A CQRS read-write separation architecture diagram with dedicated command and query paths, PostgreSQL for writes, Redis or Elasticsearch for optimized reads, and an event-driven synchronization layer with lag monitoring. This template demonstrates the core CQRS principle of separating read and write models to independently scale and optimize each path. Ideal for applications with asymmetric read/write ratios where query performance is critical.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "cqrs", + "read-write-separation", + "command-query", + "postgresql", + "redis", + "elasticsearch", + "read-model-sync", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/cqrs-read-write-separation-architecture" + }, + { + "slug": "cqrs-materialized-view-architecture", + "title": "CQRS Materialized View Architecture", + "description": "A CQRS materialized view architecture diagram with multiple projectors building purpose-specific read models: order summaries, customer dashboards, analytics cubes, and search indexes, all fed from a single event stream. This template shows how to create multiple optimized query views from the same write events, each tailored to a specific use case with sub-millisecond read latency. Perfect for systems requiring diverse query patterns from a single data source.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "materialized-view", + "cqrs", + "projectors", + "read-model", + "denormalization", + "query-optimization", + "event-stream", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/cqrs-materialized-view-architecture" + }, + { + "slug": "cqrs-task-based-ui-architecture", + "title": "CQRS Task-Based UI Architecture", + "description": "A CQRS task-based UI architecture diagram where the frontend captures user intent as explicit commands, submits them asynchronously with optimistic updates, and receives real-time confirmations via WebSocket when the read model is synchronized. This template models the modern UI pattern that replaces CRUD forms with intent-driven commands, enabling responsive user experiences with eventual consistency. Recommended for teams building reactive frontends on CQRS backends.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 19, + "numLanes": 4, + "tags": [ + "task-based-ui", + "cqrs", + "optimistic-update", + "websocket", + "command-pattern", + "idempotency", + "reactive-ui", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/cqrs-task-based-ui-architecture" + }, + { + "slug": "serverless-api-backend-architecture", + "title": "Serverless API Backend Architecture", + "description": "A serverless API backend architecture diagram with API Gateway, Lambda authorizer functions, business logic functions, and managed cloud services including DynamoDB, S3, SQS, and SNS for a fully managed, auto-scaling backend. This template models the serverless-first approach where infrastructure management is eliminated entirely, with pay-per-invocation pricing and automatic scaling to zero. Essential for startups and teams building cost-efficient, event-driven API backends.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 3, + "numNodes": 15, + "numLanes": 3, + "tags": [ + "serverless", + "aws-lambda", + "api-gateway", + "dynamodb", + "cloud-architecture", + "auto-scaling", + "pay-per-use", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "mcp/architecture/serverless-api-backend-architecture" + }, + { + "slug": "serverless-event-processing-architecture", + "title": "Serverless Event Processing Architecture", + "description": "A serverless event processing architecture diagram with S3, DynamoDB Streams, API Gateway, and CloudWatch triggers invoking Lambda functions, orchestrated by Step Functions with fan-out via SQS and dead letter queue error handling. This template shows how to build complex event processing pipelines entirely from managed serverless components, with no servers to provision or manage. Ideal for data processing workflows that need elastic scaling and built-in fault tolerance.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "serverless", + "event-processing", + "step-functions", + "lambda-triggers", + "sqs", + "s3-events", + "dynamodb-streams", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/serverless-event-processing-architecture" + }, + { + "slug": "serverless-step-functions-orchestration-architecture", + "title": "Serverless Step Functions Orchestration Architecture", + "description": "An AWS Step Functions orchestration architecture diagram with state machine workflows including choice states, parallel processing, wait-for-callback patterns, and compensation rollback for failed steps. This template models serverless workflow orchestration where complex multi-step processes are defined as state machines with built-in error handling and retry logic. Critical for teams building reliable serverless workflows that require human approval or long-running processes.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "incident", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "incident", + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 17, + "numLanes": 3, + "tags": [ + "step-functions", + "serverless-orchestration", + "state-machine", + "workflow-automation", + "callback-pattern", + "compensation", + "aws", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "incident/architecture/serverless-step-functions-orchestration-architecture" + }, + { + "slug": "serverless-edge-computing-architecture", + "title": "Serverless Edge Computing Architecture", + "description": "A serverless edge computing architecture diagram with CloudFront or Cloudflare edge locations, Lambda@Edge functions for A/B testing and geo-personalization, origin shield request collapsing, and cache-first response strategies. This template visualizes how computation moves to the network edge for ultra-low latency responses, with edge functions modifying requests and responses before they reach the origin. Essential for performance-critical applications serving global audiences.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 3, + "numNodes": 15, + "numLanes": 3, + "tags": [ + "edge-computing", + "lambda-at-edge", + "cloudfront", + "cloudflare", + "cdn", + "geo-routing", + "cache-strategy", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "handoff/architecture/serverless-edge-computing-architecture" + }, + { + "slug": "serverless-data-pipeline-architecture", + "title": "Serverless Data Pipeline Architecture", + "description": "A serverless data pipeline architecture diagram with Kinesis ingestion, Lambda transformation functions, S3 data lake storage zones (raw and curated), Glue catalog registration, and Athena query engine feeding QuickSight dashboards and SageMaker ML models. This template models a complete serverless ETL pipeline from data ingestion through transformation, cataloging, and analytics without managing any infrastructure. Ideal for data teams building cost-effective analytics platforms.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 4, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "serverless-data-pipeline", + "kinesis", + "glue", + "athena", + "s3-data-lake", + "etl", + "sagemaker", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/serverless-data-pipeline-architecture" + }, + { + "slug": "serverless-multi-cloud-architecture", + "title": "Serverless Multi-Cloud Architecture", + "description": "A multi-cloud serverless architecture diagram with DNS-based traffic routing between AWS and Azure regions, automatic failover on health check failures, and bi-directional data replication with conflict resolution across cloud providers. This template models the multi-cloud strategy for maximum availability and vendor independence, using serverless services from both AWS (Lambda, DynamoDB) and Azure (Functions, Cosmos DB). Critical for enterprises requiring cloud provider redundancy.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "multi-cloud", + "aws", + "azure", + "cloud-failover", + "dns-routing", + "data-replication", + "vendor-independence", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "handoff/architecture/serverless-multi-cloud-architecture" + }, + { + "slug": "saga-orchestration-pattern-architecture", + "title": "Saga Orchestration Pattern Architecture", + "description": "A saga orchestration architecture diagram with a central orchestrator coordinating multi-step distributed transactions across Order, Inventory, and Payment services, with a dedicated compensation chain for rollback on failure. This template models the orchestration-based saga pattern where a single coordinator manages the transaction lifecycle and triggers compensating actions when any step fails. Essential for architects implementing reliable distributed transactions without two-phase commit.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "delivery", + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 5, + "tags": [ + "saga-pattern", + "orchestration", + "distributed-transaction", + "compensation", + "microservices", + "rollback", + "consistency", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/saga-orchestration-pattern-architecture" + }, + { + "slug": "saga-choreography-pattern-architecture", + "title": "Saga Choreography Pattern Architecture", + "description": "A saga choreography architecture diagram where Order, Payment, and Inventory services coordinate through domain events without a central orchestrator, with each service publishing and subscribing to events that drive the transaction forward or trigger compensation. This template models the decentralized saga approach where services autonomously react to events, reducing single points of failure at the cost of increased complexity in tracking saga state. Best for teams preferring service autonomy over centralized control.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 18, + "numLanes": 5, + "tags": [ + "saga-choreography", + "event-driven-saga", + "decentralized", + "domain-events", + "compensation", + "autonomous-services", + "distributed-transaction", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/saga-choreography-pattern-architecture" + }, + { + "slug": "saga-distributed-transaction-architecture", + "title": "Saga Distributed Transaction Architecture", + "description": "A distributed transaction architecture diagram implementing the two-phase commit protocol with a transaction coordinator sending prepare and commit messages to participating services, with global abort on any vote failure. This template visualizes the classic 2PC protocol used when strong consistency is required across multiple services, showing the prepare, vote, and commit/abort phases. Important for understanding distributed consensus trade-offs in microservices architectures.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "ai-orchestration", + "secondaryUseCases": [], + "useCases": [ + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "distributed-transaction", + "two-phase-commit", + "2pc", + "transaction-coordinator", + "consensus", + "strong-consistency", + "prepare-commit", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "ai-orchestration/architecture/saga-distributed-transaction-architecture" + }, + { + "slug": "saga-travel-booking-architecture", + "title": "Saga Travel Booking Architecture", + "description": "A travel booking saga architecture diagram orchestrating flight, hotel, and car rental reservations as a single distributed transaction, with automatic compensation to cancel all bookings if any reservation step fails. This template models the classic saga use case where multiple independent services must either all succeed or all roll back, ensuring travelers never end up with partial bookings. Perfect for demonstrating saga patterns with a real-world business scenario.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "ai-orchestration", + "secondaryUseCases": [], + "useCases": [ + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 17, + "numLanes": 5, + "tags": [ + "saga-pattern", + "travel-booking", + "flight-reservation", + "hotel-booking", + "compensation", + "distributed-transaction", + "orchestration", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "ai-orchestration/architecture/saga-travel-booking-architecture" + }, + { + "slug": "saga-order-fulfillment-architecture", + "title": "Saga Order Fulfillment Architecture", + "description": "An order fulfillment saga architecture diagram with four sequential steps: customer verification, inventory reservation, payment authorization, and shipment creation, with a compensation chain that reverses completed steps on failure. This template models the end-to-end order lifecycle as a saga, showing how each service participates in the transaction and how compensating actions maintain data consistency. Ideal for e-commerce architects designing reliable order processing pipelines.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "approval", + "secondaryUseCases": [ + "billing", + "security" + ], + "useCases": [ + "approval", + "billing", + "security" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 3, + "tags": [ + "order-fulfillment", + "saga-pattern", + "e-commerce", + "payment-authorization", + "inventory-reservation", + "compensation-chain", + "distributed-transaction", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "approval/architecture/saga-order-fulfillment-architecture" + }, + { + "slug": "circuit-breaker-resilience-architecture", + "title": "Circuit Breaker Resilience Architecture", + "description": "A circuit breaker resilience architecture diagram showing the complete state machine with closed, open, and half-open states, failure threshold tracking, recovery timer, and fallback response strategies for protecting services from cascading failures. This template visualizes the circuit breaker pattern in detail, including how the breaker transitions between states based on success and failure counts. Essential for building fault-tolerant microservices that degrade gracefully under load.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 3, + "tags": [ + "circuit-breaker", + "resilience", + "fault-tolerance", + "cascading-failure", + "half-open-state", + "fallback", + "state-machine", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "mcp/architecture/circuit-breaker-resilience-architecture" + }, + { + "slug": "bulkhead-isolation-architecture", + "title": "Bulkhead Isolation Architecture", + "description": "A bulkhead isolation architecture diagram with separate thread pools for critical, standard, and batch workloads, each with independent connection pools, exhaustion detection, and backpressure strategies to prevent one workload from starving others. This template models the bulkhead pattern inspired by ship hull compartments, where resource isolation ensures that a failure or overload in one component cannot cascade to others. Critical for systems requiring guaranteed availability for high-priority operations.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "bulkhead-pattern", + "resource-isolation", + "thread-pool", + "backpressure", + "fault-isolation", + "resilience", + "priority-routing", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "handoff/architecture/bulkhead-isolation-architecture" + }, + { + "slug": "retry-with-exponential-backoff-architecture", + "title": "Retry with Exponential Backoff Architecture", + "description": "A retry with exponential backoff architecture diagram showing the complete retry policy engine with retryable vs non-retryable error classification, exponential delay calculation with jitter, max retry thresholds, and graceful exhaustion handling. This template models the essential resilience pattern for handling transient failures in distributed systems, preventing thundering herd problems through randomized backoff delays. Foundational for any service-to-service communication in cloud architectures.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 17, + "numLanes": 3, + "tags": [ + "retry-pattern", + "exponential-backoff", + "jitter", + "transient-failure", + "resilience", + "error-handling", + "thundering-herd", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/retry-with-exponential-backoff-architecture" + }, + { + "slug": "rate-limiter-architecture", + "title": "Rate Limiter Architecture", + "description": "A rate limiter architecture diagram implementing the token bucket algorithm with Redis-backed distributed counters, sliding window logs, API key identification, rate limit headers, and multi-node synchronization for consistent enforcement. This template shows how to protect APIs from abuse and ensure fair usage across clients, with proper HTTP 429 responses and Retry-After headers. Essential for API platform teams building production-grade rate limiting infrastructure.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "rate-limiter", + "token-bucket", + "sliding-window", + "redis", + "api-protection", + "throttling", + "distributed-rate-limiting", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/rate-limiter-architecture" + }, + { + "slug": "health-check-pattern-architecture", + "title": "Health Check Pattern Architecture", + "description": "A health check pattern architecture diagram with load balancer probes, deep health checks verifying database, cache, disk, and dependency status, automatic instance rotation, and alerting integration with PagerDuty for consecutive failures. This template models the health monitoring infrastructure that enables self-healing systems, where unhealthy instances are automatically removed from rotation and operations teams are alerted. Key for building production-ready services with proper observability.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "incident", + "secondaryUseCases": [ + "security" + ], + "useCases": [ + "incident", + "security" + ], + "complexity": 3, + "numNodes": 19, + "numLanes": 4, + "tags": [ + "health-check", + "load-balancer", + "self-healing", + "monitoring", + "pagerduty", + "instance-rotation", + "deep-health-check", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "incident/architecture/health-check-pattern-architecture" + }, + { + "slug": "hexagonal-ports-adapters-architecture", + "title": "Hexagonal (Ports and Adapters) Architecture", + "description": "A hexagonal architecture diagram showing the clean separation between domain core, inbound adapters (REST, GraphQL, CLI, message consumers), outbound adapters (PostgreSQL, Stripe, email, Redis), and the port interfaces that connect them. This template visualizes the ports and adapters pattern where the domain core has zero dependencies on infrastructure, making it fully testable and technology-agnostic. Foundational for teams adopting clean architecture principles in their codebase.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 16, + "numLanes": 4, + "tags": [ + "hexagonal-architecture", + "ports-and-adapters", + "clean-architecture", + "dependency-inversion", + "domain-core", + "testability", + "technology-agnostic", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/hexagonal-ports-adapters-architecture" + }, + { + "slug": "clean-architecture-layers", + "title": "Clean Architecture Layers", + "description": "A clean architecture layers diagram showing the four concentric layers: Entities (domain), Use Cases (application), Interface Adapters (controllers, presenters, repositories), and Frameworks & Drivers (web server, database, cloud SDK). This template models Uncle Bob's Clean Architecture with the dependency rule where inner layers never depend on outer layers, ensuring the domain model remains pure and framework-independent. Essential reference for software architects enforcing architectural boundaries.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 3, + "numNodes": 16, + "numLanes": 4, + "tags": [ + "clean-architecture", + "uncle-bob", + "dependency-rule", + "layered-architecture", + "use-cases", + "entities", + "interface-adapters", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/clean-architecture-layers" + }, + { + "slug": "domain-driven-design-bounded-contexts-architecture", + "title": "Domain-Driven Design Bounded Contexts Architecture", + "description": "A DDD bounded contexts architecture diagram with Order, Customer, Shipping, and Billing contexts connected through an anti-corruption layer, shared kernel, and context map defining integration relationships. This template visualizes the strategic DDD patterns for decomposing complex domains into autonomous bounded contexts that communicate through well-defined integration events. Critical for architects applying Domain-Driven Design to large-scale enterprise systems.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 18, + "numLanes": 5, + "tags": [ + "domain-driven-design", + "bounded-context", + "anti-corruption-layer", + "context-map", + "shared-kernel", + "strategic-ddd", + "aggregate", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/domain-driven-design-bounded-contexts-architecture" + }, + { + "slug": "api-composition-pattern-architecture", + "title": "API Composition Pattern Architecture", + "description": "An API composition architecture diagram with a composer service that fans out parallel requests to multiple microservices, collects responses with timeout handling, and merges results into a single unified response with partial fallback support. This template models the API composition pattern used when a single client query requires data from multiple services, avoiding the need for direct service-to-service calls. Useful for teams building aggregation layers in microservices architectures.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "incident", + "secondaryUseCases": [], + "useCases": [ + "incident" + ], + "complexity": 3, + "numNodes": 16, + "numLanes": 3, + "tags": [ + "api-composition", + "response-aggregation", + "fan-out", + "parallel-requests", + "timeout-handling", + "partial-response", + "microservices", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "incident/architecture/api-composition-pattern-architecture" + }, + { + "slug": "outbox-pattern-reliable-messaging-architecture", + "title": "Outbox Pattern for Reliable Messaging Architecture", + "description": "A transactional outbox architecture diagram where domain writes and event publishing happen in the same database transaction, with a relay process polling the outbox table and publishing events to a message broker with guaranteed delivery. This template solves the dual-write problem where updating a database and publishing an event are not atomic, ensuring exactly-once event delivery without distributed transactions. Critical for event-driven architectures requiring reliable message publishing.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "outbox-pattern", + "transactional-outbox", + "reliable-messaging", + "dual-write", + "exactly-once", + "debezium", + "event-publishing", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/outbox-pattern-reliable-messaging-architecture" + }, + { + "slug": "ambassador-pattern-architecture", + "title": "Ambassador Pattern Architecture", + "description": "An ambassador pattern architecture diagram with a local proxy sidecar handling authentication header injection, circuit breaking, retry logic, and metrics collection for outbound requests to external third-party APIs. This template models the ambassador pattern where a helper service running alongside the application offloads cross-cutting concerns for external communication. Useful for teams integrating with unreliable third-party services that need resilience wrappers.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 3, + "numNodes": 15, + "numLanes": 3, + "tags": [ + "ambassador-pattern", + "sidecar-proxy", + "external-api", + "retry-logic", + "circuit-breaker", + "metrics-collection", + "cross-cutting-concerns", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "mcp/architecture/ambassador-pattern-architecture" + }, + { + "slug": "graphql-federation-architecture", + "title": "GraphQL Federation Architecture", + "description": "A GraphQL federation architecture diagram with an Apollo Gateway building query plans and fanning out to User, Product, and Review subgraphs, each owning its schema and database, with response stitching into a unified GraphQL result. This template models the federated GraphQL approach where multiple teams independently develop and deploy their subgraphs while clients see a single unified API. Ideal for organizations scaling GraphQL across multiple teams and services.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 3, + "numNodes": 15, + "numLanes": 3, + "tags": [ + "graphql-federation", + "apollo-gateway", + "subgraph", + "schema-stitching", + "query-plan", + "federated-api", + "graphql", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "mcp/architecture/graphql-federation-architecture" + }, + { + "slug": "zero-trust-security-architecture", + "title": "Zero Trust Security Architecture", + "description": "A zero trust security architecture diagram with device posture checks, MFA identity verification, risk-based policy decisions, short-lived JWT tokens, micro-segmentation, mTLS encryption, least-privilege access enforcement, and continuous monitoring. This template models the 'never trust, always verify' security paradigm where every request is authenticated and authorized regardless of network location. Essential for security architects implementing modern zero-trust frameworks in cloud-native environments.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "security", + "secondaryUseCases": [], + "useCases": [ + "security" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 4, + "tags": [ + "zero-trust", + "security-architecture", + "mfa", + "micro-segmentation", + "mtls", + "least-privilege", + "continuous-verification", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "security/architecture/zero-trust-security-architecture" + }, + { + "slug": "multi-tenant-saas-architecture", + "title": "Multi-Tenant SaaS Architecture", + "description": "A multi-tenant SaaS architecture diagram with tenant identification, tier-based routing (shared vs dedicated pools), row-level security, per-tenant encryption keys, and isolated backup strategies for standard and enterprise isolation models. This template models the architecture decisions for building SaaS platforms that serve multiple customers from shared infrastructure while maintaining strict data isolation. Critical for SaaS architects balancing cost efficiency with enterprise security requirements.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "security", + "secondaryUseCases": [ + "delivery" + ], + "useCases": [ + "security", + "delivery" + ], + "complexity": 4, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "multi-tenant", + "saas-architecture", + "tenant-isolation", + "row-level-security", + "shared-infrastructure", + "enterprise-tier", + "data-isolation", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "security/architecture/multi-tenant-saas-architecture" + }, + { + "slug": "kubernetes-container-orchestration-architecture", + "title": "Kubernetes Container Orchestration Architecture", + "description": "A Kubernetes container orchestration architecture diagram showing the control plane (API Server, etcd, Scheduler, Controller Manager), worker nodes (Kubelet, container runtime, kube-proxy, pods), networking layer (Ingress, Network Policy, Service Mesh), and persistent storage with CSI drivers. This template provides a comprehensive view of the Kubernetes architecture stack from control plane to storage layer. Foundational reference for DevOps engineers and platform teams managing Kubernetes clusters.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "ai-orchestration", + "secondaryUseCases": [], + "useCases": [ + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 18, + "numLanes": 4, + "tags": [ + "kubernetes", + "container-orchestration", + "k8s", + "control-plane", + "worker-node", + "ingress", + "persistent-storage", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "ai-orchestration/architecture/kubernetes-container-orchestration-architecture" + }, + { + "slug": "data-mesh-architecture", + "title": "Data Mesh Architecture", + "description": "A data mesh architecture diagram with domain-oriented data ownership across Sales, Marketing, and Finance domains, each exposing self-serve data products through APIs with quality SLAs, governed by a federated data platform with a shared catalog and cross-domain query engine. This template models the paradigm shift from centralized data teams to domain-owned data products, applying microservices principles to data architecture. Essential for organizations scaling data operations beyond centralized data warehouse bottlenecks.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "data-mesh", + "domain-ownership", + "data-product", + "self-serve-data", + "federated-governance", + "data-platform", + "data-architecture", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/data-mesh-architecture" + }, + { + "slug": "cell-based-architecture", + "title": "Cell-Based Architecture", + "description": "A cell-based architecture diagram with geographic routing to independent, self-contained cells (US-East, EU-West), each with its own gateway, compute, database, cache, and message queue, plus shared services for cross-cell replication and global configuration. This template models the cell architecture pattern used by hyperscale systems to achieve blast radius isolation, where failures in one cell cannot affect users in another. Key for architects designing systems that require extreme availability and fault isolation.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "handoff", + "secondaryUseCases": [], + "useCases": [ + "handoff" + ], + "complexity": 4, + "numNodes": 20, + "numLanes": 4, + "tags": [ + "cell-based-architecture", + "blast-radius", + "geographic-routing", + "fault-isolation", + "independent-cells", + "cross-cell-replication", + "hyperscale", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "handoff/architecture/cell-based-architecture" + }, + { + "slug": "observability-three-pillars-architecture", + "title": "Observability Three Pillars Architecture", + "description": "An observability architecture diagram implementing the three pillars (metrics, traces, logs) with OpenTelemetry SDK instrumentation, OTLP collector pipeline, Prometheus, Jaeger, and Loki backends, Grafana dashboards, SLO/SLI tracking, and PagerDuty alerting integration. This template provides a complete observability stack reference showing how telemetry data flows from application instrumentation through collection, storage, visualization, and incident response. Essential for SRE teams building production monitoring infrastructure.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 17, + "numLanes": 4, + "tags": [ + "observability", + "three-pillars", + "opentelemetry", + "prometheus", + "jaeger", + "loki", + "grafana", + "slo-sli", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/observability-three-pillars-architecture" + }, + { + "slug": "gitops-deployment-architecture", + "title": "GitOps Deployment Architecture", + "description": "A GitOps deployment architecture diagram with developer Git workflow, CI/CD pipeline building and pushing container images, ArgoCD or Flux detecting Git manifest changes, drift detection, automatic cluster synchronization, and rolling update deployment to Kubernetes. This template models the GitOps paradigm where Git is the single source of truth for both application code and infrastructure state, enabling declarative, auditable, and reproducible deployments. Critical for teams adopting GitOps practices for Kubernetes deployments.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [], + "useCases": [ + "delivery" + ], + "complexity": 4, + "numNodes": 19, + "numLanes": 4, + "tags": [ + "gitops", + "argocd", + "flux", + "kubernetes-deployment", + "declarative-infrastructure", + "drift-detection", + "rolling-update", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/gitops-deployment-architecture" + }, + { + "slug": "ai-native-single-agent-architecture", + "title": "AI-Native Single Agent Architecture", + "description": "A single-agent AI architecture where one agent handles everything: parsing requests, reasoning, calling tools via MCP, and generating responses. This is the default architecture for prototypes and simple automations—easy to debug but hits context-window limits quickly and is hard to parallelize. Ideal for MVPs and solo builders shipping fast.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration", + "mcp" + ], + "useCases": [ + "agentic", + "ai-orchestration", + "mcp" + ], + "complexity": 2, + "numNodes": 11, + "numLanes": 3, + "tags": [ + "ai-native", + "single-agent", + "agentic-ai", + "mcp", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-native-single-agent-architecture" + }, + { + "slug": "ai-native-sequential-pipeline-architecture", + "title": "AI-Native Sequential Pipeline Architecture", + "description": "A sequential pipeline architecture chaining multiple agents in a fixed order (parse → enrich → analyze → format), which is a common 'LLM microservices' setup when each step can be isolated. This structure is often used in document processing and ETL-like workflows because each step is testable and predictable.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [ + "agentic", + "ai-orchestration" + ], + "useCases": [ + "delivery", + "agentic", + "ai-orchestration" + ], + "complexity": 2, + "numNodes": 7, + "numLanes": 2, + "tags": [ + "ai-native", + "sequential-pipeline", + "agentic-ai", + "llm-microservices", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/ai-native-sequential-pipeline-architecture" + }, + { + "slug": "ai-native-orchestrator-worker-architecture", + "title": "AI-Native Orchestrator-Worker Architecture", + "description": "An orchestrator-worker architecture where an orchestrator agent breaks a goal into subtasks, dispatches to specialized workers, then synthesizes a final response. This is the most common 'agent orchestration' architecture—powerful but the orchestrator can become a bottleneck as the number of workers grows. Frameworks like LangGraph focus on explicit routing/state to manage this.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "numNodes": 14, + "numLanes": 4, + "tags": [ + "ai-native", + "orchestrator-worker", + "agentic-ai", + "langgraph", + "multi-agent", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-native-orchestrator-worker-architecture" + }, + { + "slug": "ai-native-hierarchical-architecture", + "title": "AI-Native Hierarchical Architecture", + "description": "A hierarchical multi-agent architecture that scales orchestration by stacking supervisors and team leads (a tree structure), which mirrors enterprise org structures and helps partition context. This is the 'enterprise-grade agentic AI architecture' when a single orchestrator cannot manage all workers directly. Ideal for large enterprises and multi-domain workflows.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 16, + "numLanes": 4, + "tags": [ + "ai-native", + "hierarchical", + "agentic-ai", + "enterprise", + "multi-agent", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-native-hierarchical-architecture" + }, + { + "slug": "ai-native-parallel-fan-out-architecture", + "title": "AI-Native Parallel Fan-Out Architecture", + "description": "A parallel fan-out architecture that runs multiple agents simultaneously on independent checks (style, security, performance) and then merges results. This is a standard multi-agent design approach for throughput, mapping cleanly to CI/CD, incident response, and research. Fan-in reconciliation becomes the subtle part.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [ + "agentic", + "ai-orchestration" + ], + "useCases": [ + "delivery", + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "numNodes": 11, + "numLanes": 2, + "tags": [ + "ai-native", + "parallel-fan-out", + "agentic-ai", + "map-reduce", + "ci-cd", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/ai-native-parallel-fan-out-architecture" + }, + { + "slug": "ai-native-event-driven-kafka-architecture", + "title": "AI-Native Event-Driven Kafka Architecture", + "description": "An event-driven agentic AI architecture that replaces the central orchestrator with Kafka/PubSub topics: agents subscribe, react, and publish new events. This aligns multi-agent systems with proven microservices choreography and is ideal for real-time, high-throughput systems and 'agent mesh' setups.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration", + "mcp" + ], + "useCases": [ + "agentic", + "ai-orchestration", + "mcp" + ], + "complexity": 3, + "numNodes": 12, + "numLanes": 5, + "tags": [ + "ai-native", + "event-driven", + "agentic-ai", + "kafka", + "pub-sub", + "agent-mesh", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-native-event-driven-kafka-architecture" + }, + { + "slug": "ai-native-generator-critic-architecture", + "title": "AI-Native Generator-Critic Architecture", + "description": "A competitive / generator-critic architecture where multiple generators produce independent answers, then an evaluator agent scores and selects the best output. This approach improves quality and reduces single-model brittleness. It's costlier (multiple LLM calls) but pays off when correctness or creativity matters more than latency.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "numNodes": 9, + "numLanes": 3, + "tags": [ + "ai-native", + "generator-critic", + "agentic-ai", + "tournament-mode", + "multi-agent", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-native-generator-critic-architecture" + }, + { + "slug": "event-driven-notification-hub-architecture", + "title": "Event-Driven Notification Hub Architecture", + "description": "An event-driven notification hub architecture diagram with multi-source event ingestion, template-based message rendering, user preference routing across email (SendGrid/SES), push (FCM), SMS (Twilio), and Slack channels, with delivery tracking and retry mechanisms. This template models a centralized notification system that decouples business services from delivery infrastructure, supporting multi-channel communication with user-controlled preferences. Ideal for platform teams building scalable notification infrastructure.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "uncategorized", + "secondaryUseCases": [], + "useCases": [], + "complexity": 4, + "numNodes": 20, + "numLanes": 3, + "tags": [ + "notification-hub", + "multi-channel", + "event-driven", + "sendgrid", + "firebase-cloud-messaging", + "twilio", + "delivery-tracking", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "uncategorized/architecture/event-driven-notification-hub-architecture" + }, + { + "slug": "agentic-supervisor-worker", + "title": "Agentic Supervisor-Worker Architecture", + "description": "A supervisor-worker multi-agent architecture where an orchestrator agent receives a high-level goal, breaks it into subtasks, delegates each to specialist worker agents (researcher, writer, QA), monitors execution, handles failures, and synthesizes results. The orchestrator manages but does not execute tasks itself.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [], + "useCases": [ + "agentic" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 4, + "tags": [ + "agentic", + "supervisor-worker", + "multi-agent", + "orchestrator", + "architecture-diagram", + "ai-team" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/agentic-supervisor-worker" + }, + { + "slug": "agentic-sequential-pipeline", + "title": "Agentic Sequential Pipeline Architecture", + "description": "A sequential pipeline multi-agent architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. No central orchestrator — the flow is deterministic like an assembly line.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [ + "agentic", + "ai-orchestration" + ], + "useCases": [ + "delivery", + "agentic", + "ai-orchestration" + ], + "complexity": 2, + "numNodes": 5, + "numLanes": 5, + "tags": [ + "agentic", + "sequential-pipeline", + "multi-agent", + "assembly-line", + "architecture-diagram", + "ai-team" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/agentic-sequential-pipeline" + }, + { + "slug": "agentic-swarm", + "title": "Agentic Swarm Architecture", + "description": "A swarm multi-agent architecture where multiple agents work on the same or related tasks simultaneously, with no central coordinator. Their outputs are then aggregated, voted on, or merged by a dedicated aggregator node. Agents may compete — the best output wins.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [], + "useCases": [ + "agentic" + ], + "complexity": 3, + "numNodes": 6, + "numLanes": 5, + "tags": [ + "agentic", + "swarm", + "multi-agent", + "parallel", + "aggregator", + "architecture-diagram", + "ai-team" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/agentic-swarm" + }, + { + "slug": "agentic-hierarchical", + "title": "Agentic Hierarchical Architecture", + "description": "A hierarchical multi-agent architecture with multi-level organizational structure. A top-level executive agent manages mid-level team lead agents, who each manage their own pool of specialist workers. Teams within teams — the hierarchy maps to domain separation.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [], + "useCases": [ + "agentic" + ], + "complexity": 4, + "numNodes": 8, + "numLanes": 7, + "tags": [ + "agentic", + "hierarchical", + "multi-agent", + "enterprise", + "architecture-diagram", + "ai-team" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/agentic-hierarchical" + }, + { + "slug": "agentic-team-of-rivals", + "title": "Agentic Team of Rivals Architecture", + "description": "The most architecturally sophisticated multi-agent pattern. Agents are assigned not just roles but opposing incentives. A Planner is optimistic about goal completion. A Critic is constitutionally skeptical and holds veto authority. Errors get caught through adversarial pressure rather than trusting a single model's self-assessment.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [], + "useCases": [ + "agentic" + ], + "complexity": 3, + "numNodes": 5, + "numLanes": 3, + "tags": [ + "agentic", + "team-of-rivals", + "multi-agent", + "critic", + "veto", + "architecture-diagram", + "ai-team" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/agentic-team-of-rivals" + }, + { + "slug": "ai-orchestration-single-agent", + "title": "AI Orchestration - Single Agent (Monolith)", + "description": "The simplest AI-native architecture — a single agent that receives user input, reasons, plans, decides on tool calls, processes results, and generates responses. Direct MCP connection over stdio or HTTP. Best for MVPs and when low latency matters.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "ai-orchestration", + "secondaryUseCases": [ + "mcp" + ], + "useCases": [ + "ai-orchestration", + "mcp" + ], + "complexity": 2, + "numNodes": 12, + "numLanes": 3, + "tags": [ + "ai-native", + "single-agent", + "monolith", + "mcp", + "architecture-diagram", + "orchestration" + ], + "sourcePath": "", + "repoPath": "ai-orchestration/architecture/ai-orchestration-single-agent" + }, + { + "slug": "ai-orchestration-sequential-pipeline", + "title": "AI Orchestration - Sequential Pipeline", + "description": "An assembly-line architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. Best for tasks with clear sequential dependencies — document processing, content production pipelines, compliance workflows.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "delivery", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "delivery", + "ai-orchestration" + ], + "complexity": 2, + "numNodes": 5, + "numLanes": 2, + "tags": [ + "ai-native", + "sequential-pipeline", + "assembly-line", + "architecture-diagram", + "orchestration" + ], + "sourcePath": "", + "repoPath": "delivery/architecture/ai-orchestration-sequential-pipeline" + }, + { + "slug": "ai-orchestration-orchestrator-worker", + "title": "AI Orchestration - Orchestrator-Worker", + "description": "A conductor-style architecture where one orchestrator agent receives a complex task, breaks it into subtasks, dispatches each to specialist worker agents (research, code, review), collects results, and synthesizes the final answer. Best for complex multi-step tasks with dynamic decomposition.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "numNodes": 15, + "numLanes": 5, + "tags": [ + "ai-native", + "orchestrator-worker", + "conductor", + "multi-agent", + "architecture-diagram", + "orchestration" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-orchestration-orchestrator-worker" + }, + { + "slug": "ai-orchestration-hierarchical", + "title": "AI Orchestration - Hierarchical (Org Chart)", + "description": "An org-chart architecture with multi-level structure. A top-level supervisor manages team leads, who each manage their own pool of specialist workers. Teams within teams. Best for enterprise-scale automation with 10+ specialized agents spanning multiple domains.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 4, + "numNodes": 17, + "numLanes": 5, + "tags": [ + "ai-native", + "hierarchical", + "org-chart", + "enterprise", + "multi-agent", + "architecture-diagram", + "orchestration" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-orchestration-hierarchical" + }, + { + "slug": "ai-orchestration-parallel-fan-out", + "title": "AI Orchestration - Parallel Fan-Out (Map-Reduce)", + "description": "A map-reduce style architecture where a coordinator fans out tasks to multiple parallel worker agents (style check, security audit, performance analysis), gathers all results, and makes an aggregate decision. Best for PR reviews, code reviews, and multi-dimensional analysis.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "numNodes": 9, + "numLanes": 3, + "tags": [ + "ai-native", + "parallel-fan-out", + "map-reduce", + "coordinator", + "multi-agent", + "architecture-diagram", + "orchestration" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-orchestration-parallel-fan-out" + }, + { + "slug": "ai-orchestration-event-driven-mesh", + "title": "AI Orchestration - Event-Driven Mesh (Kafka-First)", + "description": "An event-driven agent mesh architecture using a Kafka-style event broker. Multiple agents subscribe to topics (orders, alerts, analytics), process events independently, and publish results back to the bus. Best for real-time event processing and decoupled service architectures.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "ai-orchestration", + "secondaryUseCases": [ + "mcp" + ], + "useCases": [ + "ai-orchestration", + "mcp" + ], + "complexity": 3, + "numNodes": 13, + "numLanes": 5, + "tags": [ + "ai-native", + "event-driven", + "kafka", + "agent-mesh", + "pub-sub", + "architecture-diagram", + "orchestration" + ], + "sourcePath": "", + "repoPath": "ai-orchestration/architecture/ai-orchestration-event-driven-mesh" + }, + { + "slug": "ai-orchestration-competitive-generator-critic", + "title": "AI Orchestration - Competitive Generator-Critic", + "description": "A tournament-mode architecture where multiple generator agents produce independent outputs in parallel, then an evaluator agent scores and selects the best. Quality threshold checking with refinement loops. Best when correctness or creativity matters more than latency.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "ai-orchestration" + ], + "useCases": [ + "agentic", + "ai-orchestration" + ], + "complexity": 3, + "numNodes": 10, + "numLanes": 3, + "tags": [ + "ai-native", + "competitive", + "generator-critic", + "tournament", + "multi-agent", + "architecture-diagram", + "orchestration" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/ai-orchestration-competitive-generator-critic" + }, + { + "slug": "mcp-direct-connect", + "title": "MCP Direct Connect Architecture", + "description": "The simplest MCP pattern — direct connection between host application and MCP server over stdio or HTTP. No extra hops, lowest latency, easiest debugging. Perfect for MVPs, hackathons, and single-team setups where security governance is not yet a concern.", + "kind": "architecture", + "sourceDomain": "DevOps", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 1, + "numNodes": 6, + "numLanes": 2, + "tags": [ + "mcp", + "direct-connect", + "stdio", + "http", + "architecture-diagram", + "production-grade" + ], + "sourcePath": "", + "repoPath": "mcp/devops/mcp-direct-connect" + }, + { + "slug": "mcp-gateway-proxy", + "title": "MCP Gateway Proxy Architecture", + "description": "An API gateway pattern that sits between agents and MCP servers to handle authentication, rate limits, and auditing. The gateway enforces OAuth 2.0, SAML, SSO, tool-level rate limiting, and team-based quotas. Essential for multi-team or multi-tenant MCP deployments.", + "kind": "architecture", + "sourceDomain": "DevOps", + "primaryUseCase": "security", + "secondaryUseCases": [ + "compliance", + "mcp" + ], + "useCases": [ + "security", + "compliance", + "mcp" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 3, + "tags": [ + "mcp", + "gateway", + "proxy", + "oauth", + "rate-limiting", + "audit", + "architecture-diagram", + "production-grade" + ], + "sourcePath": "", + "repoPath": "security/devops/mcp-gateway-proxy" + }, + { + "slug": "mcp-tool-router", + "title": "MCP Tool Router Architecture", + "description": "A routing pattern that puts a semantic router in front of MCP tools so the LLM only sees the subset it needs. Uses vector embeddings and cosine similarity to match user intent to tools dynamically. Achieves up to 96% reduction in input tokens when dealing with large tool catalogs.", + "kind": "architecture", + "sourceDomain": "DevOps", + "primaryUseCase": "handoff", + "secondaryUseCases": [ + "mcp" + ], + "useCases": [ + "handoff", + "mcp" + ], + "complexity": 3, + "numNodes": 8, + "numLanes": 4, + "tags": [ + "mcp", + "tool-router", + "semantic-routing", + "embeddings", + "token-optimization", + "architecture-diagram", + "production-grade" + ], + "sourcePath": "", + "repoPath": "handoff/devops/mcp-tool-router" + }, + { + "slug": "mcp-agent-mesh", + "title": "MCP Agent Mesh Architecture", + "description": "A multi-agent mesh pattern where agents communicate through a shared context broker backed by MCP. Enables coordinated tool access and state synchronization across multiple specialized agents (planner, coder, reviewer, operator). Supports both orchestrated and choreographed interaction patterns.", + "kind": "architecture", + "sourceDomain": "DevOps", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "mcp" + ], + "useCases": [ + "agentic", + "mcp" + ], + "complexity": 4, + "numNodes": 10, + "numLanes": 4, + "tags": [ + "mcp", + "agent-mesh", + "shared-context", + "multi-agent", + "broker", + "architecture-diagram", + "production-grade" + ], + "sourcePath": "", + "repoPath": "agentic/devops/mcp-agent-mesh" + }, + { + "slug": "mcp-circuit-breaker", + "title": "MCP Circuit Breaker Architecture", + "description": "A resilience pattern that wraps MCP calls with health-aware gates using three states: Closed (normal), Open (failures detected, fast-fail), and Half-Open (testing recovery). Prevents cascading failures when tools become unresponsive. Essential for production-grade reliability.", + "kind": "architecture", + "sourceDomain": "DevOps", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 3, + "numNodes": 9, + "numLanes": 3, + "tags": [ + "mcp", + "circuit-breaker", + "resilience", + "fault-tolerance", + "health-check", + "architecture-diagram", + "production-grade" + ], + "sourcePath": "", + "repoPath": "mcp/devops/mcp-circuit-breaker" + }, + { + "slug": "mcp-context-proxy", + "title": "MCP Context Proxy Architecture", + "description": "A caching and compression layer that sits between agents and MCP servers, intercepting redundant context requests before they hit the wire. Uses TTL-based cache invalidation, Brotli compression, and semantic caching. Can achieve up to 95%+ token reduction and significantly lower LLM bills.", + "kind": "architecture", + "sourceDomain": "DevOps", + "primaryUseCase": "mcp", + "secondaryUseCases": [], + "useCases": [ + "mcp" + ], + "complexity": 3, + "numNodes": 7, + "numLanes": 3, + "tags": [ + "mcp", + "context-proxy", + "caching", + "compression", + "token-optimization", + "architecture-diagram", + "production-grade" + ], + "sourcePath": "", + "repoPath": "mcp/devops/mcp-context-proxy" + }, + { + "slug": "context-session-memory", + "title": "Context Management - Session Memory", + "description": "Short-term context pattern where the channel sends new messages plus recent history. The agent runtime merges that with local session state, assembles the prompt, and persists the response back into history. Simple but cost and latency grow with history length.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "context-management", + "secondaryUseCases": [], + "useCases": [ + "context-management" + ], + "complexity": 2, + "numNodes": 9, + "numLanes": 3, + "tags": [ + "context-management", + "session-memory", + "short-term", + "memory", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "context-management/architecture/context-session-memory" + }, + { + "slug": "context-rolling-summary-memory", + "title": "Context Management - Rolling Summary Memory", + "description": "Compressed history pattern that keeps full history for a while, then when a threshold is hit, summarizes the last chunk and replaces detailed turns with a shorter summary message. Dramatically reduces prompt size on long-running chats while maintaining gist continuity.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "context-management", + "secondaryUseCases": [], + "useCases": [ + "context-management" + ], + "complexity": 3, + "numNodes": 8, + "numLanes": 4, + "tags": [ + "context-management", + "rolling-summary", + "compression", + "memory", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "context-management/architecture/context-rolling-summary-memory" + }, + { + "slug": "context-profile-memory", + "title": "Context Management - Profile Memory", + "description": "Identity-style memory pattern where profile data is loaded at session start. Each prompt combines system persona, user profile, and current message. New facts can be written back to profile memory. Small predictable overhead with big UX lift — the agent remembers your name, stack, tone, and constraints.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "context-management", + "secondaryUseCases": [], + "useCases": [ + "context-management" + ], + "complexity": 2, + "numNodes": 7, + "numLanes": 3, + "tags": [ + "context-management", + "profile-memory", + "identity", + "user-profile", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "context-management/architecture/context-profile-memory" + }, + { + "slug": "context-semantic-memory", + "title": "Context Management - Semantic Memory", + "description": "Vector-based memory pattern where text is chunked, embedded, and stored in a vector database. On query, the question is embedded, a vector search is run, candidates are reranked, and top results are injected into the prompt. Where the agent feels like it remembers everything without hallucinating.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "context-management", + "secondaryUseCases": [], + "useCases": [ + "context-management" + ], + "complexity": 3, + "numNodes": 9, + "numLanes": 4, + "tags": [ + "context-management", + "semantic-memory", + "vector-db", + "embeddings", + "rag", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "context-management/architecture/context-semantic-memory" + }, + { + "slug": "context-episodic-memory", + "title": "Context Management - Episodic Memory", + "description": "Learning-from-experience pattern where every task run becomes an episode with input, actions, and outcome. Before tackling a new task, the agent fetches similar episodes and uses them as hints. Over time, the agent feels like it's learning instead of repeating the same failed plans.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "context-management", + "secondaryUseCases": [], + "useCases": [ + "context-management" + ], + "complexity": 3, + "numNodes": 11, + "numLanes": 4, + "tags": [ + "context-management", + "episodic-memory", + "learning", + "experience", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "context-management/architecture/context-episodic-memory" + }, + { + "slug": "context-hybrid-retrieval-memory", + "title": "Context Management - Hybrid Retrieval Memory", + "description": "Multi-modal retrieval pattern combining semantic search, exact/keyword search, and recency search in parallel. Results are merged and reranked into a single context set. Much higher recall because the agent can find both fuzzy references and exact entities. Essential for comprehensive knowledge retrieval.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "context-management", + "secondaryUseCases": [], + "useCases": [ + "context-management" + ], + "complexity": 4, + "numNodes": 11, + "numLanes": 5, + "tags": [ + "context-management", + "hybrid-retrieval", + "semantic", + "keyword", + "recency", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "context-management/architecture/context-hybrid-retrieval-memory" + }, + { + "slug": "context-shared-memory", + "title": "Context Management - Shared Memory", + "description": "Multi-agent coordination pattern where an orchestrator breaks work into subtasks, specialist agents pull from and push to a shared state store, and the orchestrator composes the final answer from that shared state. Multi-agent setups feel coherent instead of each assistant having its own inconsistent memory.", + "kind": "architecture", + "sourceDomain": "Architecture", + "primaryUseCase": "agentic", + "secondaryUseCases": [ + "context-management" + ], + "useCases": [ + "agentic", + "context-management" + ], + "complexity": 3, + "numNodes": 9, + "numLanes": 4, + "tags": [ + "context-management", + "shared-memory", + "multi-agent", + "orchestrator", + "architecture-diagram" + ], + "sourcePath": "", + "repoPath": "agentic/architecture/context-shared-memory" + } + ] +} diff --git a/uncategorized/architecture/clean-architecture-layers/README.md b/uncategorized/architecture/clean-architecture-layers/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5ffb6b636dc1267c276bce2a1c15691a69ea8904 --- /dev/null +++ b/uncategorized/architecture/clean-architecture-layers/README.md @@ -0,0 +1,19 @@ +# Clean Architecture Layers + +A clean architecture layers diagram showing the four concentric layers: Entities (domain), Use Cases (application), Interface Adapters (controllers, presenters, repositories), and Frameworks & Drivers (web server, database, cloud SDK). This template models Uncle Bob's Clean Architecture with the dependency rule where inner layers never depend on outer layers, ensuring the domain model remains pure and framework-independent. Essential reference for software architects enforcing architectural boundaries. + +**Template ID:** `clean-architecture-layers` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 16 +**Lanes:** 4 +**Tags:** [clean-architecture, uncle-bob, dependency-rule, layered-architecture, use-cases, entities, interface-adapters, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/clean-architecture-layers` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/clean-architecture-layers/metadata.json b/uncategorized/architecture/clean-architecture-layers/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..da1aa0f751ea61eb46cc4c322e7f4f28a996500c --- /dev/null +++ b/uncategorized/architecture/clean-architecture-layers/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "clean-architecture-layers", + "workflow_id": "clean-architecture-layers", + "title": "Clean Architecture Layers", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 16, + "num_lanes": 4, + "tags": [ + "clean-architecture", + "uncle-bob", + "dependency-rule", + "layered-architecture", + "use-cases", + "entities", + "interface-adapters", + "architecture-diagram" + ], + "description": "A clean architecture layers diagram showing the four concentric layers: Entities (domain), Use Cases (application), Interface Adapters (controllers, presenters, repositories), and Frameworks & Drivers (web server, database, cloud SDK). This template models Uncle Bob's Clean Architecture with the dependency rule where inner layers never depend on outer layers, ensuring the domain model remains pure and framework-independent. Essential reference for software architects enforcing architectural boundaries.", + "source_path": "", + "repo_path": "uncategorized/architecture/clean-architecture-layers" +} diff --git a/uncategorized/architecture/clean-architecture-layers/workflow.fz b/uncategorized/architecture/clean-architecture-layers/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c454535bb7f463d3b7494c26958eb0c24afef237 --- /dev/null +++ b/uncategorized/architecture/clean-architecture-layers/workflow.fz @@ -0,0 +1,41 @@ +External { # External Layer (Frameworks & Drivers) +n1: rectangle label:"Express/Fastify Web Server" +n2: rectangle label:"PostgreSQL Driver" +n3: rectangle label:"Redis Client" +n4: rectangle label:"AWS SDK" +n17: rectangle label:"Return View Model" +n1.handle(bottom) -> Interface.n5.handle(top) [label="HTTP Request"] +n2.handle(bottom) -> Interface.n7.handle(top) [label="DB Connection"] +n3.handle(bottom) -> Interface.n7.handle(top) [label="Cache"] +n4.handle(bottom) -> Interface.n7.handle(top) [label="Cloud Storage"] +} +Interface { # Interface Adapters Layer +n5: rectangle label:"Controller" +n6: rectangle label:"DTO Mapper" +n7: rectangle label:"Repository Implementation" +n16: rectangle label:"Presenter" +n5.handle(right) -> n6.handle(left) [label="Map Input"] +n6.handle(bottom) -> UseCase.n8.handle(top) [label="Request Model"] +n7.handle(bottom) -> UseCase.n11.handle(top) [label="Implements"] +n16.handle(top) -> External.n17.handle(bottom) [label="View Model"] +} +UseCase { # Use Cases Layer (Application) +n8: rectangle label:"Create Order Use Case" +n9: rectangle label:"Get Order Use Case" +n10: rectangle label:"Cancel Order Use Case" +n11: rectangle label:"Order Repository Interface" +n8.handle(bottom) -> Entity.n12.handle(top) [label="Call Domain"] +n9.handle(bottom) -> Entity.n12.handle(top) [label="Query"] +n10.handle(bottom) -> Entity.n13.handle(top) [label="Cancel"] +n8.handle(right) -> n11.handle(left) [label="Persist"] +n9.handle(top) -> Interface.n16.handle(bottom) [label="Output"] +} +Entity { # Entities Layer (Domain) +n12: rectangle label:"Order Aggregate Root" +n13: rectangle label:"Order Item Entity" +n14: rectangle label:"Money Value Object" +n15: rectangle label:"Order Status Enum" +n12.handle(right) -> n13.handle(left) [label="Contains"] +n13.handle(right) -> n14.handle(left) [label="Uses"] +n12.handle(bottom) -> n15.handle(top) [label="State"] +} diff --git a/uncategorized/architecture/cqrs-materialized-view-architecture/README.md b/uncategorized/architecture/cqrs-materialized-view-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6b3e50431793a9bb3a7aa965e70622b4e161d394 --- /dev/null +++ b/uncategorized/architecture/cqrs-materialized-view-architecture/README.md @@ -0,0 +1,19 @@ +# CQRS Materialized View Architecture + +A CQRS materialized view architecture diagram with multiple projectors building purpose-specific read models: order summaries, customer dashboards, analytics cubes, and search indexes, all fed from a single event stream. This template shows how to create multiple optimized query views from the same write events, each tailored to a specific use case with sub-millisecond read latency. Perfect for systems requiring diverse query patterns from a single data source. + +**Template ID:** `cqrs-materialized-view-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [materialized-view, cqrs, projectors, read-model, denormalization, query-optimization, event-stream, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/cqrs-materialized-view-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/cqrs-materialized-view-architecture/metadata.json b/uncategorized/architecture/cqrs-materialized-view-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3bca803fa2f36b5ab49d7a172808593a0195930a --- /dev/null +++ b/uncategorized/architecture/cqrs-materialized-view-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "cqrs-materialized-view-architecture", + "workflow_id": "cqrs-materialized-view-architecture", + "title": "CQRS Materialized View Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "materialized-view", + "cqrs", + "projectors", + "read-model", + "denormalization", + "query-optimization", + "event-stream", + "architecture-diagram" + ], + "description": "A CQRS materialized view architecture diagram with multiple projectors building purpose-specific read models: order summaries, customer dashboards, analytics cubes, and search indexes, all fed from a single event stream. This template shows how to create multiple optimized query views from the same write events, each tailored to a specific use case with sub-millisecond read latency. Perfect for systems requiring diverse query patterns from a single data source.", + "source_path": "", + "repo_path": "uncategorized/architecture/cqrs-materialized-view-architecture" +} diff --git a/uncategorized/architecture/cqrs-materialized-view-architecture/workflow.fz b/uncategorized/architecture/cqrs-materialized-view-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ebd6ad62aa489d8f14f086bfdb784a1a2cdf19f3 --- /dev/null +++ b/uncategorized/architecture/cqrs-materialized-view-architecture/workflow.fz @@ -0,0 +1,43 @@ +WriteModel { # Write Model +n1: circle label:"Incoming Command" +n2: rectangle label:"Command Handler" +n3: rectangle label:"Validate Against Aggregate" +n4: rectangle label:"Persist to Write Store" +n5: rectangle label:"Emit Domain Event" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) [label="Normalized"] +n4.handle(right) -> n5.handle(left) [label="After Commit"] +n5.handle(bottom) -> EventBus.n6.handle(top) [label="Publish"] +} +EventBus { # Event Bus +n6: rectangle label:"Route Event" +n7: rectangle label:"Guarantee Ordering" +n8: rectangle label:"Deliver to Projectors" +n6.handle(right) -> n7.handle(left) [label="Partition Key"] +n7.handle(right) -> n8.handle(left) +n8.handle(bottom) -> Projectors.n9.handle(top) [label="Fan-Out"] +} +Projectors { # View Projectors +n9: rectangle label:"Order Summary Projector" +n10: rectangle label:"Customer Dashboard Projector" +n11: rectangle label:"Analytics Projector" +n12: rectangle label:"Search Index Projector" +n9.handle(bottom) -> Views.n13.handle(top) [label="Build View"] +n10.handle(bottom) -> Views.n14.handle(top) [label="Build View"] +n11.handle(bottom) -> Views.n15.handle(top) [label="Build View"] +n12.handle(bottom) -> Views.n16.handle(top) [label="Build View"] +} +Views { # Materialized Views +n13: rectangle label:"Order Summary Table" +n14: rectangle label:"Customer Dashboard Cache" +n15: rectangle label:"Analytics Cube" +n16: rectangle label:"Elasticsearch Index" +n17: rectangle label:"Query API" +n18: circle label:"Fast Read Response" +n13.handle(right) -> n17.handle(left) +n14.handle(right) -> n17.handle(left) +n15.handle(right) -> n17.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Sub-ms Latency"] +} diff --git a/uncategorized/architecture/cqrs-read-write-separation-architecture/README.md b/uncategorized/architecture/cqrs-read-write-separation-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c315951128c2d78c3f2ff304a1d0c25e3d40000d --- /dev/null +++ b/uncategorized/architecture/cqrs-read-write-separation-architecture/README.md @@ -0,0 +1,19 @@ +# CQRS Read-Write Separation Architecture + +A CQRS read-write separation architecture diagram with dedicated command and query paths, PostgreSQL for writes, Redis or Elasticsearch for optimized reads, and an event-driven synchronization layer with lag monitoring. This template demonstrates the core CQRS principle of separating read and write models to independently scale and optimize each path. Ideal for applications with asymmetric read/write ratios where query performance is critical. + +**Template ID:** `cqrs-read-write-separation-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [cqrs, read-write-separation, command-query, postgresql, redis, elasticsearch, read-model-sync, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/cqrs-read-write-separation-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/cqrs-read-write-separation-architecture/metadata.json b/uncategorized/architecture/cqrs-read-write-separation-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..479ceffe93cb890843f8d47b608e156bedcdb8fc --- /dev/null +++ b/uncategorized/architecture/cqrs-read-write-separation-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "cqrs-read-write-separation-architecture", + "workflow_id": "cqrs-read-write-separation-architecture", + "title": "CQRS Read-Write Separation Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "cqrs", + "read-write-separation", + "command-query", + "postgresql", + "redis", + "elasticsearch", + "read-model-sync", + "architecture-diagram" + ], + "description": "A CQRS read-write separation architecture diagram with dedicated command and query paths, PostgreSQL for writes, Redis or Elasticsearch for optimized reads, and an event-driven synchronization layer with lag monitoring. This template demonstrates the core CQRS principle of separating read and write models to independently scale and optimize each path. Ideal for applications with asymmetric read/write ratios where query performance is critical.", + "source_path": "", + "repo_path": "uncategorized/architecture/cqrs-read-write-separation-architecture" +} diff --git a/uncategorized/architecture/cqrs-read-write-separation-architecture/workflow.fz b/uncategorized/architecture/cqrs-read-write-separation-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..281118793e8ea3c35d669a4e202ad493dd99669f --- /dev/null +++ b/uncategorized/architecture/cqrs-read-write-separation-architecture/workflow.fz @@ -0,0 +1,50 @@ +Client { # Client Application +n1: circle label:"User Action" +n2: diamond label:"Read or Write?" +n19: rectangle label:"Display Query Result" +n20: rectangle label:"Confirm Write Success" +n21: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> WritePath.n3.handle(top) [label="Command"] +n2.handle(right) -> ReadPath.n9.handle(left) [label="Query"] +n19.handle(right) -> n21.handle(left) +n20.handle(right) -> n21.handle(left) +} +WritePath { # Write Path (Command) +n3: rectangle label:"Command Validator" +n4: rectangle label:"Domain Aggregate" +n5: rectangle label:"Write Database (PostgreSQL)" +n6: rectangle label:"Publish Change Event" +n7: rectangle label:"Send Write Confirmation" +n8: rectangle label:"Forward ACK" +n3.handle(right) -> n4.handle(left) [label="Validated"] +n4.handle(right) -> n5.handle(left) [label="Persist"] +n5.handle(right) -> n6.handle(left) [label="Committed"] +n6.handle(bottom) -> Sync.n15.handle(top) [label="DomainEvent"] +n5.handle(bottom) -> n7.handle(top) [label="ACK"] +n7.handle(right) -> n8.handle(left) +n8.handle(top) -> Client.n20.handle(bottom) [label="Write OK"] +} +ReadPath { # Read Path (Query) +n9: rectangle label:"Query Router" +n10: rectangle label:"Read Database (Redis/Elastic)" +n11: rectangle label:"Transform to DTO" +n12: rectangle label:"Return Response" +n13: rectangle label:"Send Query Result" +n14: rectangle label:"Forward Result" +n9.handle(right) -> n10.handle(left) [label="Optimized Query"] +n10.handle(right) -> n11.handle(left) [label="Denormalized"] +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(top) -> Client.n19.handle(bottom) [label="JSON"] +} +Sync { # Synchronization Layer +n15: rectangle label:"Event Consumer" +n16: rectangle label:"Transform for Read Model" +n17: rectangle label:"Update Read Database" +n18: rectangle label:"Sync Complete" +n15.handle(right) -> n16.handle(left) [label="Consume"] +n16.handle(right) -> n17.handle(left) [label="Upsert"] +n17.handle(right) -> n18.handle(left) [label="Updated"] +} diff --git a/uncategorized/architecture/cqrs-task-based-ui-architecture/README.md b/uncategorized/architecture/cqrs-task-based-ui-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d21c73d88fe25d5ba496cbd8d8f214f7ccc5dd0a --- /dev/null +++ b/uncategorized/architecture/cqrs-task-based-ui-architecture/README.md @@ -0,0 +1,19 @@ +# CQRS Task-Based UI Architecture + +A CQRS task-based UI architecture diagram where the frontend captures user intent as explicit commands, submits them asynchronously with optimistic updates, and receives real-time confirmations via WebSocket when the read model is synchronized. This template models the modern UI pattern that replaces CRUD forms with intent-driven commands, enabling responsive user experiences with eventual consistency. Recommended for teams building reactive frontends on CQRS backends. + +**Template ID:** `cqrs-task-based-ui-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 4 +**Tags:** [task-based-ui, cqrs, optimistic-update, websocket, command-pattern, idempotency, reactive-ui, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/cqrs-task-based-ui-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/cqrs-task-based-ui-architecture/metadata.json b/uncategorized/architecture/cqrs-task-based-ui-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..987c1e35417e8d277b43dfeae371bf8813a7cad9 --- /dev/null +++ b/uncategorized/architecture/cqrs-task-based-ui-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "cqrs-task-based-ui-architecture", + "workflow_id": "cqrs-task-based-ui-architecture", + "title": "CQRS Task-Based UI Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 4, + "tags": [ + "task-based-ui", + "cqrs", + "optimistic-update", + "websocket", + "command-pattern", + "idempotency", + "reactive-ui", + "architecture-diagram" + ], + "description": "A CQRS task-based UI architecture diagram where the frontend captures user intent as explicit commands, submits them asynchronously with optimistic updates, and receives real-time confirmations via WebSocket when the read model is synchronized. This template models the modern UI pattern that replaces CRUD forms with intent-driven commands, enabling responsive user experiences with eventual consistency. Recommended for teams building reactive frontends on CQRS backends.", + "source_path": "", + "repo_path": "uncategorized/architecture/cqrs-task-based-ui-architecture" +} diff --git a/uncategorized/architecture/cqrs-task-based-ui-architecture/workflow.fz b/uncategorized/architecture/cqrs-task-based-ui-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..780cacad8e04ade4bdddfe3f21f18ff59379d584 --- /dev/null +++ b/uncategorized/architecture/cqrs-task-based-ui-architecture/workflow.fz @@ -0,0 +1,48 @@ +UI { # Task-Based UI +n1: circle label:"User Intent" +n2: rectangle label:"Render Task Form" +n3: rectangle label:"Capture User Intent as Command" +n4: rectangle label:"Submit Command" +n23: rectangle label:"Show Optimistic Update" +n24: circle label:"UI Confirmed" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="PlaceOrder"] +n3.handle(right) -> n4.handle(left) [label="Command DTO"] +n4.handle(bottom) -> CommandAPI.n5.handle(top) [label="POST /commands"] +n23.handle(right) -> n24.handle(left) +} +CommandAPI { # Command API +n5: rectangle label:"Deserialize Command" +n6: rectangle label:"Authorize User" +n7: diamond label:"Idempotency Check" +n8: rectangle label:"Dispatch to Handler" +n9: rectangle label:"Return 202 Accepted" +n10: rectangle label:"Return 409 Duplicate" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="New"] +n7.handle(bottom) -> n10.handle(top) [label="Duplicate"] +n8.handle(right) -> n9.handle(left) [label="Queued"] +n8.handle(bottom) -> Domain.n11.handle(top) [label="Process"] +n9.handle(top) -> UI.n23.handle(bottom) [label="202 Accepted"] +} +Domain { # Domain Model +n11: rectangle label:"Load Aggregate" +n12: rectangle label:"Execute Business Logic" +n13: rectangle label:"Persist State Change" +n14: rectangle label:"Emit Events" +n11.handle(right) -> n12.handle(left) [label="Current State"] +n12.handle(right) -> n13.handle(left) [label="New State"] +n13.handle(right) -> n14.handle(left) [label="Committed"] +n14.handle(bottom) -> QuerySync.n15.handle(top) [label="Async"] +} +QuerySync { # Query Synchronization +n15: rectangle label:"Update Read Model" +n16: rectangle label:"Invalidate Cache" +n17: rectangle label:"Push via WebSocket" +n18: rectangle label:"Send Confirmed Update" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Real-Time"] +n17.handle(right) -> n18.handle(left) +n18.handle(top) -> UI.n23.handle(bottom) [label="Confirmed"] +} diff --git a/uncategorized/architecture/data-mesh-architecture/README.md b/uncategorized/architecture/data-mesh-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9dec35b7ac23474c3ede4f16e3dbcbe7870904c --- /dev/null +++ b/uncategorized/architecture/data-mesh-architecture/README.md @@ -0,0 +1,19 @@ +# Data Mesh Architecture + +A data mesh architecture diagram with domain-oriented data ownership across Sales, Marketing, and Finance domains, each exposing self-serve data products through APIs with quality SLAs, governed by a federated data platform with a shared catalog and cross-domain query engine. This template models the paradigm shift from centralized data teams to domain-owned data products, applying microservices principles to data architecture. Essential for organizations scaling data operations beyond centralized data warehouse bottlenecks. + +**Template ID:** `data-mesh-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [data-mesh, domain-ownership, data-product, self-serve-data, federated-governance, data-platform, data-architecture, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/data-mesh-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/data-mesh-architecture/metadata.json b/uncategorized/architecture/data-mesh-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..cecdcdab4bedba0086248c40e1c4efb586835126 --- /dev/null +++ b/uncategorized/architecture/data-mesh-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "data-mesh-architecture", + "workflow_id": "data-mesh-architecture", + "title": "Data Mesh Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "data-mesh", + "domain-ownership", + "data-product", + "self-serve-data", + "federated-governance", + "data-platform", + "data-architecture", + "architecture-diagram" + ], + "description": "A data mesh architecture diagram with domain-oriented data ownership across Sales, Marketing, and Finance domains, each exposing self-serve data products through APIs with quality SLAs, governed by a federated data platform with a shared catalog and cross-domain query engine. This template models the paradigm shift from centralized data teams to domain-owned data products, applying microservices principles to data architecture. Essential for organizations scaling data operations beyond centralized data warehouse bottlenecks.", + "source_path": "", + "repo_path": "uncategorized/architecture/data-mesh-architecture" +} diff --git a/uncategorized/architecture/data-mesh-architecture/workflow.fz b/uncategorized/architecture/data-mesh-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..f6e53a4073c58bbdc0bcd2c83c12faefd331e127 --- /dev/null +++ b/uncategorized/architecture/data-mesh-architecture/workflow.fz @@ -0,0 +1,41 @@ +SalesDomain { # Sales Data Domain +n1: rectangle label:"Sales Data Product Owner" +n2: rectangle label:"Sales Pipeline Dataset" +n3: rectangle label:"Self-Serve Data API" +n4: rectangle label:"Data Quality SLA" +n1.handle(right) -> n2.handle(left) [label="Owns"] +n2.handle(right) -> n3.handle(left) [label="Expose"] +n3.handle(right) -> n4.handle(left) [label="Monitor"] +n3.handle(bottom) -> Platform.n13.handle(top) [label="Register"] +} +MarketingDomain { # Marketing Data Domain +n5: rectangle label:"Marketing Data Product Owner" +n6: rectangle label:"Campaign Analytics Dataset" +n7: rectangle label:"Self-Serve Data API" +n8: rectangle label:"Data Quality SLA" +n5.handle(right) -> n6.handle(left) [label="Owns"] +n6.handle(right) -> n7.handle(left) [label="Expose"] +n7.handle(right) -> n8.handle(left) [label="Monitor"] +n7.handle(bottom) -> Platform.n13.handle(top) [label="Register"] +} +FinanceDomain { # Finance Data Domain +n9: rectangle label:"Finance Data Product Owner" +n10: rectangle label:"Revenue Reporting Dataset" +n11: rectangle label:"Self-Serve Data API" +n12: rectangle label:"Data Quality SLA" +n9.handle(right) -> n10.handle(left) [label="Owns"] +n10.handle(right) -> n11.handle(left) [label="Expose"] +n11.handle(right) -> n12.handle(left) [label="Monitor"] +n11.handle(bottom) -> Platform.n13.handle(top) [label="Register"] +} +Platform { # Self-Serve Data Platform +n13: rectangle label:"Data Product Catalog" +n14: rectangle label:"Federated Governance" +n15: rectangle label:"Shared Infrastructure" +n16: rectangle label:"Data Mesh Gateway" +n17: rectangle label:"Cross-Domain Query Engine" +n13.handle(right) -> n14.handle(left) [label="Policies"] +n14.handle(right) -> n15.handle(left) [label="Standards"] +n15.handle(right) -> n16.handle(left) [label="Access"] +n16.handle(right) -> n17.handle(left) [label="Federated Query"] +} diff --git a/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/README.md b/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..db75f40138b02caaa1fc63bd2e1d44eabff15a5c --- /dev/null +++ b/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/README.md @@ -0,0 +1,19 @@ +# Domain-Driven Design Bounded Contexts Architecture + +A DDD bounded contexts architecture diagram with Order, Customer, Shipping, and Billing contexts connected through an anti-corruption layer, shared kernel, and context map defining integration relationships. This template visualizes the strategic DDD patterns for decomposing complex domains into autonomous bounded contexts that communicate through well-defined integration events. Critical for architects applying Domain-Driven Design to large-scale enterprise systems. + +**Template ID:** `domain-driven-design-bounded-contexts-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 5 +**Tags:** [domain-driven-design, bounded-context, anti-corruption-layer, context-map, shared-kernel, strategic-ddd, aggregate, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/domain-driven-design-bounded-contexts-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/metadata.json b/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bc14082ac9571f2f573ae8db748b2e35ec5eb434 --- /dev/null +++ b/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "domain-driven-design-bounded-contexts-architecture", + "workflow_id": "domain-driven-design-bounded-contexts-architecture", + "title": "Domain-Driven Design Bounded Contexts Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 5, + "tags": [ + "domain-driven-design", + "bounded-context", + "anti-corruption-layer", + "context-map", + "shared-kernel", + "strategic-ddd", + "aggregate", + "architecture-diagram" + ], + "description": "A DDD bounded contexts architecture diagram with Order, Customer, Shipping, and Billing contexts connected through an anti-corruption layer, shared kernel, and context map defining integration relationships. This template visualizes the strategic DDD patterns for decomposing complex domains into autonomous bounded contexts that communicate through well-defined integration events. Critical for architects applying Domain-Driven Design to large-scale enterprise systems.", + "source_path": "", + "repo_path": "uncategorized/architecture/domain-driven-design-bounded-contexts-architecture" +} diff --git a/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/workflow.fz b/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..5c245d91fda1e61b6c817d3a81ac3a079414e813 --- /dev/null +++ b/uncategorized/architecture/domain-driven-design-bounded-contexts-architecture/workflow.fz @@ -0,0 +1,67 @@ +OrderContext { # Order Bounded Context +n1: rectangle label:"Order Service" +n2: rectangle label:"Order Aggregate" +n3: rectangle label:"Order Line Item" +n4: rectangle label:"Order Repository" +n27: rectangle label:"Receive Shipping Ack" +n28: rectangle label:"Order Shipping Confirmed" +n1.handle(right) -> n2.handle(left) [label="Manages"] +n2.handle(right) -> n3.handle(left) [label="Contains"] +n3.handle(right) -> n4.handle(left) [label="Persists"] +n1.handle(bottom) -> ACL.n9.handle(top) [label="Integration Event"] +n27.handle(right) -> n28.handle(left) +} +CustomerContext { # Customer Bounded Context +n5: rectangle label:"Customer Service" +n6: rectangle label:"Customer Aggregate" +n7: rectangle label:"Address Value Object" +n8: rectangle label:"Customer Repository" +n29: rectangle label:"Receive Billing Ack" +n30: rectangle label:"Invoice Confirmed" +n5.handle(right) -> n6.handle(left) [label="Manages"] +n6.handle(right) -> n7.handle(left) [label="Has"] +n7.handle(right) -> n8.handle(left) [label="Persists"] +n5.handle(bottom) -> ACL.n10.handle(top) [label="Integration Event"] +n29.handle(right) -> n30.handle(left) +} +ACL { # Anti-Corruption Layer +n9: rectangle label:"Order-to-Shipping Translator" +n10: rectangle label:"Customer-to-Billing Translator" +n11: rectangle label:"Shared Kernel (Common Types)" +n12: rectangle label:"Context Map" +n23: rectangle label:"Receive Shipping Result" +n24: rectangle label:"Forward to OrderContext" +n25: rectangle label:"Receive Billing Result" +n26: rectangle label:"Forward to CustomerContext" +n9.handle(bottom) -> ShippingContext.n13.handle(top) [label="ShipmentRequested"] +n10.handle(bottom) -> BillingContext.n19.handle(top) [label="InvoiceRequested"] +n11.handle(right) -> n12.handle(left) [label="Defines"] +n23.handle(right) -> n24.handle(left) +n24.handle(top) -> OrderContext.n27.handle(bottom) [label="Shipping Ack"] +n25.handle(right) -> n26.handle(left) +n26.handle(top) -> CustomerContext.n29.handle(bottom) [label="Billing Ack"] +} +ShippingContext { # Shipping Bounded Context +n13: rectangle label:"Shipping Service" +n14: rectangle label:"Shipment Aggregate" +n15: rectangle label:"Tracking Number VO" +n16: rectangle label:"Confirm Shipment" +n17: rectangle label:"Return Shipping Result" +n18: rectangle label:"Send to ACL" +n13.handle(right) -> n14.handle(left) [label="Manages"] +n14.handle(right) -> n15.handle(left) [label="Assigned"] +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(top) -> ACL.n23.handle(bottom) [label="ShipmentConfirmed"] +} +BillingContext { # Billing Bounded Context +n19: rectangle label:"Billing Service" +n20: rectangle label:"Invoice Aggregate" +n21: rectangle label:"Payment Entity" +n22: rectangle label:"Return Billing Result" +n19.handle(right) -> n20.handle(left) [label="Manages"] +n20.handle(right) -> n21.handle(left) [label="Contains"] +n21.handle(right) -> n22.handle(left) +n22.handle(top) -> ACL.n25.handle(bottom) [label="InvoiceConfirmed"] +} diff --git a/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/README.md b/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2aecd7c510898c8eb22435010da755fd81408b77 --- /dev/null +++ b/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven CDC (Change Data Capture) Architecture + +A Change Data Capture architecture diagram using Debezium to tail database transaction logs and publish change events to Kafka, feeding downstream consumers that update search indexes, invalidate caches, load data warehouses, and write audit logs. This template shows how CDC eliminates dual-write problems by capturing changes at the database level without modifying application code. Critical for data synchronization across heterogeneous systems. + +**Template ID:** `event-driven-cdc-change-data-capture-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [change-data-capture, cdc, debezium, transaction-log, kafka-connect, data-synchronization, dual-write, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/event-driven-cdc-change-data-capture-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/metadata.json b/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b69ff30ce588a5c998695edaa8975c3be03d4f47 --- /dev/null +++ b/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "event-driven-cdc-change-data-capture-architecture", + "workflow_id": "event-driven-cdc-change-data-capture-architecture", + "title": "Event-Driven CDC (Change Data Capture) Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "change-data-capture", + "cdc", + "debezium", + "transaction-log", + "kafka-connect", + "data-synchronization", + "dual-write", + "architecture-diagram" + ], + "description": "A Change Data Capture architecture diagram using Debezium to tail database transaction logs and publish change events to Kafka, feeding downstream consumers that update search indexes, invalidate caches, load data warehouses, and write audit logs. This template shows how CDC eliminates dual-write problems by capturing changes at the database level without modifying application code. Critical for data synchronization across heterogeneous systems.", + "source_path": "", + "repo_path": "uncategorized/architecture/event-driven-cdc-change-data-capture-architecture" +} diff --git a/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/workflow.fz b/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c7812013fea2cdacc57aaf18133fd4e31652af30 --- /dev/null +++ b/uncategorized/architecture/event-driven-cdc-change-data-capture-architecture/workflow.fz @@ -0,0 +1,41 @@ +SourceDB { # Source Database +n1: circle label:"Data Write Operation" +n2: rectangle label:"Transaction Log (WAL)" +n3: rectangle label:"Commit to Database" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Persist"] +n2.handle(bottom) -> CDC.n4.handle(top) [label="Log Tail"] +} +CDC { # CDC Engine (Debezium) +n4: rectangle label:"Read Transaction Log" +n5: rectangle label:"Detect Change Event" +n6: rectangle label:"Serialize to Avro/JSON" +n7: diamond label:"Schema Changed?" +n8: rectangle label:"Update Schema Registry" +n9: rectangle label:"Publish Change Event" +n4.handle(right) -> n5.handle(left) [label="INSERT/UPDATE/DELETE"] +n5.handle(right) -> n6.handle(left) [label="Before + After"] +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n9.handle(left) [label="No"] +n7.handle(bottom) -> n8.handle(top) [label="Yes"] +n8.handle(right) -> n9.handle(left) [label="Registered"] +n9.handle(bottom) -> Consumers.n10.handle(top) [label="Kafka Topic"] +} +Consumers { # Downstream Consumers +n10: rectangle label:"Search Index Updater" +n11: rectangle label:"Cache Invalidator" +n12: rectangle label:"Data Warehouse Loader" +n13: rectangle label:"Audit Log Writer" +n10.handle(right) -> n11.handle(left) [label="Elasticsearch"] +n12.handle(right) -> n13.handle(left) [label="Snowflake"] +} +TargetDB { # Target Systems +n14: rectangle label:"Elasticsearch Index" +n15: rectangle label:"Redis Cache" +n16: rectangle label:"Data Warehouse" +n17: rectangle label:"Audit Database" +n10.handle(bottom) -> TargetDB.n14.handle(top) [label="Upsert Doc"] +n11.handle(bottom) -> TargetDB.n15.handle(top) [label="Invalidate"] +n12.handle(bottom) -> TargetDB.n16.handle(top) [label="Load"] +n13.handle(bottom) -> TargetDB.n17.handle(top) [label="Append"] +} diff --git a/uncategorized/architecture/event-driven-choreography-architecture/README.md b/uncategorized/architecture/event-driven-choreography-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..effb3e75529cb6e01a23bbf5c76a1776081da526 --- /dev/null +++ b/uncategorized/architecture/event-driven-choreography-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven Choreography Architecture + +An event-driven choreography architecture diagram where microservices coordinate through events without a central orchestrator, with Order, Payment, Inventory, and Shipping services reacting to each other's domain events. This template models the decentralized coordination pattern where each service knows only its own responsibilities and publishes events for others to consume. Best for teams favoring autonomous services over centralized workflow control. + +**Template ID:** `event-driven-choreography-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 5 +**Tags:** [choreography, event-driven, decentralized-coordination, domain-events, microservices, autonomous-services, pub-sub, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/event-driven-choreography-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/event-driven-choreography-architecture/metadata.json b/uncategorized/architecture/event-driven-choreography-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..1d4ac368b7e83e10801c02705df7eae61ce9e022 --- /dev/null +++ b/uncategorized/architecture/event-driven-choreography-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "event-driven-choreography-architecture", + "workflow_id": "event-driven-choreography-architecture", + "title": "Event-Driven Choreography Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 5, + "tags": [ + "choreography", + "event-driven", + "decentralized-coordination", + "domain-events", + "microservices", + "autonomous-services", + "pub-sub", + "architecture-diagram" + ], + "description": "An event-driven choreography architecture diagram where microservices coordinate through events without a central orchestrator, with Order, Payment, Inventory, and Shipping services reacting to each other's domain events. This template models the decentralized coordination pattern where each service knows only its own responsibilities and publishes events for others to consume. Best for teams favoring autonomous services over centralized workflow control.", + "source_path": "", + "repo_path": "uncategorized/architecture/event-driven-choreography-architecture" +} diff --git a/uncategorized/architecture/event-driven-choreography-architecture/workflow.fz b/uncategorized/architecture/event-driven-choreography-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0b26d655e243677dff0bb9f5decbe2ada6f9421e --- /dev/null +++ b/uncategorized/architecture/event-driven-choreography-architecture/workflow.fz @@ -0,0 +1,47 @@ +OrderService { # Order Service +n1: circle label:"New Order Received" +n2: rectangle label:"Validate Order" +n3: rectangle label:"Emit OrderCreated Event" +n17: rectangle label:"Receive Payment Confirmation" +n18: rectangle label:"Update Order Status" +n19: circle label:"Order Complete" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Valid"] +n3.handle(bottom) -> EventBus.n4.handle(top) [label="Publish"] +n17.handle(right) -> n18.handle(left) [label="Confirmed"] +n18.handle(right) -> n19.handle(left) +} +EventBus { # Event Bus +n4: rectangle label:"OrderCreated Topic" +n8: rectangle label:"PaymentConfirmed Topic" +n12: rectangle label:"InventoryReserved Topic" +n16: rectangle label:"ShipmentScheduled Topic" +n4.handle(bottom) -> PaymentService.n5.handle(top) [label="Subscribe"] +n8.handle(top) -> OrderService.n17.handle(bottom) [label="Notify"] +n8.handle(bottom) -> InventoryService.n9.handle(top) [label="Subscribe"] +n12.handle(bottom) -> ShippingService.n13.handle(top) [label="Subscribe"] +} +PaymentService { # Payment Service +n5: rectangle label:"Receive OrderCreated" +n6: rectangle label:"Process Payment" +n7: rectangle label:"Emit PaymentConfirmed" +n5.handle(right) -> n6.handle(left) [label="Charge"] +n6.handle(right) -> n7.handle(left) [label="Success"] +n7.handle(top) -> EventBus.n8.handle(bottom) [label="Publish"] +} +InventoryService { # Inventory Service +n9: rectangle label:"Receive PaymentConfirmed" +n10: rectangle label:"Reserve Stock" +n11: rectangle label:"Emit InventoryReserved" +n9.handle(right) -> n10.handle(left) [label="Allocate"] +n10.handle(right) -> n11.handle(left) [label="Reserved"] +n11.handle(top) -> EventBus.n12.handle(bottom) [label="Publish"] +} +ShippingService { # Shipping Service +n13: rectangle label:"Receive InventoryReserved" +n14: rectangle label:"Schedule Shipment" +n15: rectangle label:"Emit ShipmentScheduled" +n13.handle(right) -> n14.handle(left) [label="Plan Route"] +n14.handle(right) -> n15.handle(left) [label="Scheduled"] +n15.handle(top) -> EventBus.n16.handle(bottom) [label="Publish"] +} diff --git a/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/README.md b/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f80a09a94038ff970f087c3809cff3daa5217a7f --- /dev/null +++ b/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven CQRS with Event Store Architecture + +A CQRS architecture diagram combining separate command and query APIs with an event bus for asynchronous read model synchronization, including projectors that build denormalized views from domain events. This template demonstrates the full CQRS+ES stack where writes go through domain validation and reads are served from optimized materialized views. Ideal for high-throughput systems where read and write workloads have fundamentally different scaling requirements. + +**Template ID:** `event-driven-cqrs-with-event-store-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [cqrs, event-store, command-query-separation, read-model, write-model, projector, eventual-consistency, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/event-driven-cqrs-with-event-store-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/metadata.json b/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..93d66b92504c17c4dfd80d416f150a6da7483375 --- /dev/null +++ b/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "event-driven-cqrs-with-event-store-architecture", + "workflow_id": "event-driven-cqrs-with-event-store-architecture", + "title": "Event-Driven CQRS with Event Store Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "cqrs", + "event-store", + "command-query-separation", + "read-model", + "write-model", + "projector", + "eventual-consistency", + "architecture-diagram" + ], + "description": "A CQRS architecture diagram combining separate command and query APIs with an event bus for asynchronous read model synchronization, including projectors that build denormalized views from domain events. This template demonstrates the full CQRS+ES stack where writes go through domain validation and reads are served from optimized materialized views. Ideal for high-throughput systems where read and write workloads have fundamentally different scaling requirements.", + "source_path": "", + "repo_path": "uncategorized/architecture/event-driven-cqrs-with-event-store-architecture" +} diff --git a/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/workflow.fz b/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..59290c84b50ae8f67560dcda6d7b1931a9f41ec1 --- /dev/null +++ b/uncategorized/architecture/event-driven-cqrs-with-event-store-architecture/workflow.fz @@ -0,0 +1,43 @@ +WriteAPI { # Write API (Command) +n1: circle label:"POST/PUT Request" +n2: rectangle label:"Command Handler" +n3: rectangle label:"Validate Business Rules" +n4: rectangle label:"Persist to Write DB" +n5: rectangle label:"Publish Domain Event" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) [label="Valid"] +n4.handle(right) -> n5.handle(left) [label="Committed"] +n5.handle(bottom) -> EventBus.n6.handle(top) [label="OrderPlaced"] +} +EventBus { # Event Bus (Kafka) +n6: rectangle label:"Receive Domain Event" +n7: rectangle label:"Route to Topic" +n8: rectangle label:"Guarantee Delivery" +n9: rectangle label:"Fan-Out to Consumers" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="At-Least-Once"] +n8.handle(right) -> n9.handle(left) +n9.handle(bottom) -> Projector.n10.handle(top) [label="Consume"] +} +Projector { # Read Model Projector +n10: rectangle label:"Event Handler" +n11: rectangle label:"Update Read Model" +n12: rectangle label:"Rebuild Materialized View" +n13: diamond label:"Consistency Check" +n14: rectangle label:"Mark Projection Current" +n10.handle(right) -> n11.handle(left) [label="Transform"] +n11.handle(right) -> n12.handle(left) [label="Upsert"] +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Consistent"] +n14.handle(bottom) -> ReadSide.n15.handle(top) [label="Updated"] +} +ReadSide { # Read API (Query) +n15: rectangle label:"Query Handler" +n16: rectangle label:"Read from Read DB" +n17: rectangle label:"Transform to DTO" +n18: circle label:"GET Response" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Denormalized"] +n17.handle(right) -> n18.handle(left) +} diff --git a/uncategorized/architecture/event-driven-event-sourcing-architecture/README.md b/uncategorized/architecture/event-driven-event-sourcing-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8215c111c868cc7512e81d6c14085a5cd26f1329 --- /dev/null +++ b/uncategorized/architecture/event-driven-event-sourcing-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven Event Sourcing Architecture + +An event sourcing architecture diagram where all state changes are stored as an immutable sequence of domain events, with read projections built from the event stream and snapshot optimization for fast aggregate loading. This template shows how event sourcing eliminates data loss by preserving the complete history of every state transition. Critical for systems requiring full audit trails, temporal queries, and event replay capabilities. + +**Template ID:** `event-driven-event-sourcing-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [event-sourcing, immutable-events, event-store, projections, snapshot, aggregate, temporal-query, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/event-driven-event-sourcing-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/event-driven-event-sourcing-architecture/metadata.json b/uncategorized/architecture/event-driven-event-sourcing-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ebe7575d755a08a6ceace8dfc87e3c79e7183543 --- /dev/null +++ b/uncategorized/architecture/event-driven-event-sourcing-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "event-driven-event-sourcing-architecture", + "workflow_id": "event-driven-event-sourcing-architecture", + "title": "Event-Driven Event Sourcing Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "event-sourcing", + "immutable-events", + "event-store", + "projections", + "snapshot", + "aggregate", + "temporal-query", + "architecture-diagram" + ], + "description": "An event sourcing architecture diagram where all state changes are stored as an immutable sequence of domain events, with read projections built from the event stream and snapshot optimization for fast aggregate loading. This template shows how event sourcing eliminates data loss by preserving the complete history of every state transition. Critical for systems requiring full audit trails, temporal queries, and event replay capabilities.", + "source_path": "", + "repo_path": "uncategorized/architecture/event-driven-event-sourcing-architecture" +} diff --git a/uncategorized/architecture/event-driven-event-sourcing-architecture/workflow.fz b/uncategorized/architecture/event-driven-event-sourcing-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d49f8c4b97522f5871c74a2833312a22568368fd --- /dev/null +++ b/uncategorized/architecture/event-driven-event-sourcing-architecture/workflow.fz @@ -0,0 +1,44 @@ +Command { # Command Side +n1: circle label:"User Command" +n2: rectangle label:"Validate Command" +n3: rectangle label:"Load Aggregate" +n4: rectangle label:"Apply Business Rules" +n5: rectangle label:"Emit Domain Events" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Valid"] +n3.handle(right) -> n4.handle(left) [label="Current State"] +n4.handle(right) -> n5.handle(left) [label="State Change"] +n5.handle(bottom) -> EventStore.n6.handle(top) [label="Append"] +} +EventStore { # Event Store +n6: rectangle label:"Append Event to Stream" +n7: rectangle label:"Assign Sequence Number" +n8: rectangle label:"Persist Immutable Event" +n9: rectangle label:"Publish to Projections" +n10: rectangle label:"Snapshot Manager" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Write-Ahead Log"] +n8.handle(right) -> n9.handle(left) [label="Notify"] +n8.handle(bottom) -> n10.handle(top) [label="Checkpoint"] +n9.handle(bottom) -> Projections.n11.handle(top) [label="Event Stream"] +} +Projections { # Read Projections +n11: rectangle label:"Event Handler" +n12: rectangle label:"Build Read Model" +n13: rectangle label:"Update Materialized View" +n14: rectangle label:"Serve Query" +n15: circle label:"Query Response" +n11.handle(right) -> n12.handle(left) [label="Transform"] +n12.handle(right) -> n13.handle(left) [label="Upsert"] +n13.handle(right) -> n14.handle(left) [label="Ready"] +n14.handle(right) -> n15.handle(left) +} +Replay { # Event Replay +n16: rectangle label:"Replay from Offset" +n17: rectangle label:"Rebuild Projection" +n18: rectangle label:"Verify Consistency" +n19: rectangle label:"Projection Rebuilt" +n16.handle(right) -> n17.handle(left) [label="Historical Events"] +n17.handle(right) -> n18.handle(left) [label="Rebuilt"] +n18.handle(right) -> n19.handle(left) [label="Consistent"] +} diff --git a/uncategorized/architecture/event-driven-notification-hub-architecture/README.md b/uncategorized/architecture/event-driven-notification-hub-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a5354292600421adbb8e48065f5fafe9a91731d0 --- /dev/null +++ b/uncategorized/architecture/event-driven-notification-hub-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven Notification Hub Architecture + +An event-driven notification hub architecture diagram with multi-source event ingestion, template-based message rendering, user preference routing across email (SendGrid/SES), push (FCM), SMS (Twilio), and Slack channels, with delivery tracking and retry mechanisms. This template models a centralized notification system that decouples business services from delivery infrastructure, supporting multi-channel communication with user-controlled preferences. Ideal for platform teams building scalable notification infrastructure. + +**Template ID:** `event-driven-notification-hub-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 20 +**Lanes:** 3 +**Tags:** [notification-hub, multi-channel, event-driven, sendgrid, firebase-cloud-messaging, twilio, delivery-tracking, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/event-driven-notification-hub-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/event-driven-notification-hub-architecture/metadata.json b/uncategorized/architecture/event-driven-notification-hub-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9749ebd7873a09fdc47124505a48680a2d3060ca --- /dev/null +++ b/uncategorized/architecture/event-driven-notification-hub-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "event-driven-notification-hub-architecture", + "workflow_id": "event-driven-notification-hub-architecture", + "title": "Event-Driven Notification Hub Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 20, + "num_lanes": 3, + "tags": [ + "notification-hub", + "multi-channel", + "event-driven", + "sendgrid", + "firebase-cloud-messaging", + "twilio", + "delivery-tracking", + "architecture-diagram" + ], + "description": "An event-driven notification hub architecture diagram with multi-source event ingestion, template-based message rendering, user preference routing across email (SendGrid/SES), push (FCM), SMS (Twilio), and Slack channels, with delivery tracking and retry mechanisms. This template models a centralized notification system that decouples business services from delivery infrastructure, supporting multi-channel communication with user-controlled preferences. Ideal for platform teams building scalable notification infrastructure.", + "source_path": "", + "repo_path": "uncategorized/architecture/event-driven-notification-hub-architecture" +} diff --git a/uncategorized/architecture/event-driven-notification-hub-architecture/workflow.fz b/uncategorized/architecture/event-driven-notification-hub-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..945ad3439a1d326f40b6ac5f16ed58941e800914 --- /dev/null +++ b/uncategorized/architecture/event-driven-notification-hub-architecture/workflow.fz @@ -0,0 +1,48 @@ +Sources { # Event Sources +n1: rectangle label:"Order Service Event" +n2: rectangle label:"User Service Event" +n3: rectangle label:"Payment Service Event" +n4: rectangle label:"System Alert Event" +n1.handle(bottom) -> Hub.n5.handle(top) [label="OrderShipped"] +n2.handle(bottom) -> Hub.n5.handle(top) [label="AccountCreated"] +n3.handle(bottom) -> Hub.n5.handle(top) [label="PaymentFailed"] +n4.handle(bottom) -> Hub.n5.handle(top) [label="SystemDown"] +} +Hub { # Notification Hub +n5: rectangle label:"Receive Event" +n6: rectangle label:"Resolve Notification Template" +n7: rectangle label:"Check User Preferences" +n8: diamond label:"Channel Preference?" +n9: rectangle label:"Route to Email Channel" +n10: rectangle label:"Route to Push Channel" +n11: rectangle label:"Route to SMS Channel" +n12: rectangle label:"Route to Slack Channel" +n5.handle(right) -> n6.handle(left) [label="Match Template"] +n6.handle(right) -> n7.handle(left) [label="Render"] +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Email"] +n8.handle(bottom) -> n10.handle(top) [label="Push"] +n8.handle(left) -> n11.handle(right) [label="SMS"] +n8.handle(bottom) -> n12.handle(top) [label="Slack"] +n9.handle(bottom) -> Delivery.n13.handle(top) [label="Send"] +n10.handle(bottom) -> Delivery.n14.handle(top) [label="Send"] +n11.handle(bottom) -> Delivery.n15.handle(top) [label="Send"] +n12.handle(bottom) -> Delivery.n16.handle(top) [label="Send"] +} +Delivery { # Delivery Providers +n13: rectangle label:"SendGrid / SES" +n14: rectangle label:"Firebase Cloud Messaging" +n15: rectangle label:"Twilio SMS" +n16: rectangle label:"Slack Webhook" +n17: rectangle label:"Delivery Status Tracker" +n18: diamond label:"Delivered?" +n19: rectangle label:"Log Success" +n20: rectangle label:"Retry or DLQ" +n13.handle(right) -> n17.handle(left) [label="Callback"] +n14.handle(right) -> n17.handle(left) [label="Callback"] +n15.handle(right) -> n17.handle(left) [label="Callback"] +n16.handle(right) -> n17.handle(left) [label="Callback"] +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Yes"] +n18.handle(bottom) -> n20.handle(top) [label="No"] +} diff --git a/uncategorized/architecture/event-driven-publish-subscribe-architecture/README.md b/uncategorized/architecture/event-driven-publish-subscribe-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..441b88b3c6b46e9bc8536e0688eef6452681c1d5 --- /dev/null +++ b/uncategorized/architecture/event-driven-publish-subscribe-architecture/README.md @@ -0,0 +1,19 @@ +# Event-Driven Publish-Subscribe Architecture + +An event-driven publish-subscribe architecture diagram with Kafka or RabbitMQ message broker, event serialization, topic partitioning, fan-out delivery to multiple consumers, and dead letter queue error handling. This template models the foundational async messaging pattern where producers and consumers are fully decoupled through a message broker. Essential for architects building loosely coupled, scalable event-driven systems. + +**Template ID:** `event-driven-publish-subscribe-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 3 +**Tags:** [publish-subscribe, event-driven, kafka, rabbitmq, message-broker, fan-out, dead-letter-queue, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/event-driven-publish-subscribe-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/event-driven-publish-subscribe-architecture/metadata.json b/uncategorized/architecture/event-driven-publish-subscribe-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b7c4fffcac477b1832301960f85a95a362750d85 --- /dev/null +++ b/uncategorized/architecture/event-driven-publish-subscribe-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "event-driven-publish-subscribe-architecture", + "workflow_id": "event-driven-publish-subscribe-architecture", + "title": "Event-Driven Publish-Subscribe Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 3, + "tags": [ + "publish-subscribe", + "event-driven", + "kafka", + "rabbitmq", + "message-broker", + "fan-out", + "dead-letter-queue", + "architecture-diagram" + ], + "description": "An event-driven publish-subscribe architecture diagram with Kafka or RabbitMQ message broker, event serialization, topic partitioning, fan-out delivery to multiple consumers, and dead letter queue error handling. This template models the foundational async messaging pattern where producers and consumers are fully decoupled through a message broker. Essential for architects building loosely coupled, scalable event-driven systems.", + "source_path": "", + "repo_path": "uncategorized/architecture/event-driven-publish-subscribe-architecture" +} diff --git a/uncategorized/architecture/event-driven-publish-subscribe-architecture/workflow.fz b/uncategorized/architecture/event-driven-publish-subscribe-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..7e1b1ee3f328c416a6026db234a4e8dffba68687 --- /dev/null +++ b/uncategorized/architecture/event-driven-publish-subscribe-architecture/workflow.fz @@ -0,0 +1,37 @@ +Producer { # Event Producer +n1: circle label:"Business Action" +n2: rectangle label:"Create Domain Event" +n3: rectangle label:"Serialize Event" +n4: rectangle label:"Publish to Topic" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="OrderCreated"] +n3.handle(right) -> n4.handle(left) [label="Avro/JSON"] +n4.handle(bottom) -> Broker.n5.handle(top) [label="Produce"] +} +Broker { # Message Broker (Kafka/RabbitMQ) +n5: rectangle label:"Receive Event" +n6: rectangle label:"Partition by Key" +n7: rectangle label:"Persist to Log" +n8: rectangle label:"Fan-Out to Subscribers" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) [label="Append"] +n7.handle(right) -> n8.handle(left) [label="Notify"] +n8.handle(bottom) -> Consumers.n9.handle(top) [label="Deliver"] +} +Consumers { # Event Consumers +n9: rectangle label:"Inventory Consumer" +n10: diamond label:"Processing OK?" +n11: rectangle label:"Update Stock Level" +n12: rectangle label:"Send to Dead Letter Queue" +n13: rectangle label:"Notification Consumer" +n14: rectangle label:"Send Order Email" +n15: rectangle label:"Analytics Consumer" +n16: rectangle label:"Update Dashboard" +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n12.handle(top) [label="No"] +n11.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Email"] +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Aggregate"] +} diff --git a/uncategorized/architecture/hexagonal-ports-adapters-architecture/README.md b/uncategorized/architecture/hexagonal-ports-adapters-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3d48f72afedd9dc0c7b9f9fae2accb5b401d5a63 --- /dev/null +++ b/uncategorized/architecture/hexagonal-ports-adapters-architecture/README.md @@ -0,0 +1,19 @@ +# Hexagonal (Ports and Adapters) Architecture + +A hexagonal architecture diagram showing the clean separation between domain core, inbound adapters (REST, GraphQL, CLI, message consumers), outbound adapters (PostgreSQL, Stripe, email, Redis), and the port interfaces that connect them. This template visualizes the ports and adapters pattern where the domain core has zero dependencies on infrastructure, making it fully testable and technology-agnostic. Foundational for teams adopting clean architecture principles in their codebase. + +**Template ID:** `hexagonal-ports-adapters-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 16 +**Lanes:** 4 +**Tags:** [hexagonal-architecture, ports-and-adapters, clean-architecture, dependency-inversion, domain-core, testability, technology-agnostic, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/hexagonal-ports-adapters-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/hexagonal-ports-adapters-architecture/metadata.json b/uncategorized/architecture/hexagonal-ports-adapters-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ea28a3ee6ccd6e1627ec965a496ed6176ddec014 --- /dev/null +++ b/uncategorized/architecture/hexagonal-ports-adapters-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "hexagonal-ports-adapters-architecture", + "workflow_id": "hexagonal-ports-adapters-architecture", + "title": "Hexagonal (Ports and Adapters) Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 16, + "num_lanes": 4, + "tags": [ + "hexagonal-architecture", + "ports-and-adapters", + "clean-architecture", + "dependency-inversion", + "domain-core", + "testability", + "technology-agnostic", + "architecture-diagram" + ], + "description": "A hexagonal architecture diagram showing the clean separation between domain core, inbound adapters (REST, GraphQL, CLI, message consumers), outbound adapters (PostgreSQL, Stripe, email, Redis), and the port interfaces that connect them. This template visualizes the ports and adapters pattern where the domain core has zero dependencies on infrastructure, making it fully testable and technology-agnostic. Foundational for teams adopting clean architecture principles in their codebase.", + "source_path": "", + "repo_path": "uncategorized/architecture/hexagonal-ports-adapters-architecture" +} diff --git a/uncategorized/architecture/hexagonal-ports-adapters-architecture/workflow.fz b/uncategorized/architecture/hexagonal-ports-adapters-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6898d0b11ce91efc7a9b40cb9e8467f6daee5ec7 --- /dev/null +++ b/uncategorized/architecture/hexagonal-ports-adapters-architecture/workflow.fz @@ -0,0 +1,41 @@ +InboundAdapters { # Inbound Adapters (Driving) +n1: rectangle label:"REST Controller" +n2: rectangle label:"GraphQL Resolver" +n3: rectangle label:"CLI Command Handler" +n4: rectangle label:"Message Consumer" +n1.handle(bottom) -> Ports.n5.handle(top) [label="Port: CreateOrder"] +n2.handle(bottom) -> Ports.n5.handle(top) [label="Port: CreateOrder"] +n3.handle(bottom) -> Ports.n6.handle(top) [label="Port: RunReport"] +n4.handle(bottom) -> Ports.n6.handle(top) [label="Port: ProcessEvent"] +} +Ports { # Ports (Interfaces) +n5: rectangle label:"Inbound Port: OrderUseCase" +n6: rectangle label:"Inbound Port: ReportUseCase" +n5.handle(bottom) -> Core.n7.handle(top) [label="Implement"] +n6.handle(bottom) -> Core.n8.handle(top) [label="Implement"] +} +Core { # Domain Core (Hexagon) +n7: rectangle label:"Order Service" +n8: rectangle label:"Report Service" +n9: rectangle label:"Domain Model (Entities)" +n10: rectangle label:"Business Rules (Value Objects)" +n7.handle(right) -> n9.handle(left) [label="Use"] +n8.handle(right) -> n9.handle(left) [label="Use"] +n9.handle(right) -> n10.handle(left) [label="Enforce"] +n7.handle(bottom) -> OutboundPorts.n11.handle(top) [label="Call Port"] +n8.handle(bottom) -> OutboundPorts.n12.handle(top) [label="Call Port"] +} +OutboundPorts { # Outbound Ports +n11: rectangle label:"Outbound Port: OrderRepository" +n12: rectangle label:"Outbound Port: PaymentGateway" +n11.handle(bottom) -> OutboundAdapters.n13.handle(top) [label="Implements"] +n12.handle(bottom) -> OutboundAdapters.n14.handle(top) [label="Implements"] +} +OutboundAdapters { # Outbound Adapters (Driven) +n13: rectangle label:"PostgreSQL Repository" +n14: rectangle label:"Stripe Payment Adapter" +n15: rectangle label:"Email Notification Adapter" +n16: rectangle label:"Redis Cache Adapter" +n13.handle(right) -> n15.handle(left) +n14.handle(right) -> n16.handle(left) +} diff --git a/uncategorized/architecture/microservices-backend-for-frontend-architecture/README.md b/uncategorized/architecture/microservices-backend-for-frontend-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1fda0e68282571ebd5dfe36dd5c48514cf1b2ab7 --- /dev/null +++ b/uncategorized/architecture/microservices-backend-for-frontend-architecture/README.md @@ -0,0 +1,19 @@ +# Microservices Backend-for-Frontend (BFF) Architecture + +A Backend-for-Frontend architecture diagram with separate BFF layers for web and mobile clients, each optimizing API responses for their specific platform while sharing common backend microservices. This template shows how to avoid one-size-fits-all APIs by tailoring data aggregation and payload optimization per client type. Recommended for teams serving multiple frontend platforms from a shared microservices backend. + +**Template ID:** `microservices-backend-for-frontend-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 12 +**Lanes:** 3 +**Tags:** [backend-for-frontend, bff-pattern, mobile-api, web-api, api-aggregation, payload-optimization, microservices, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/microservices-backend-for-frontend-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/microservices-backend-for-frontend-architecture/metadata.json b/uncategorized/architecture/microservices-backend-for-frontend-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d12fe7c5987469be25acc772f358cefa313416be --- /dev/null +++ b/uncategorized/architecture/microservices-backend-for-frontend-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "microservices-backend-for-frontend-architecture", + "workflow_id": "microservices-backend-for-frontend-architecture", + "title": "Microservices Backend-for-Frontend (BFF) Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 12, + "num_lanes": 3, + "tags": [ + "backend-for-frontend", + "bff-pattern", + "mobile-api", + "web-api", + "api-aggregation", + "payload-optimization", + "microservices", + "architecture-diagram" + ], + "description": "A Backend-for-Frontend architecture diagram with separate BFF layers for web and mobile clients, each optimizing API responses for their specific platform while sharing common backend microservices. This template shows how to avoid one-size-fits-all APIs by tailoring data aggregation and payload optimization per client type. Recommended for teams serving multiple frontend platforms from a shared microservices backend.", + "source_path": "", + "repo_path": "uncategorized/architecture/microservices-backend-for-frontend-architecture" +} diff --git a/uncategorized/architecture/microservices-backend-for-frontend-architecture/workflow.fz b/uncategorized/architecture/microservices-backend-for-frontend-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..be1db2f175dd3fa37bc784130ba1051f9d5ed257 --- /dev/null +++ b/uncategorized/architecture/microservices-backend-for-frontend-architecture/workflow.fz @@ -0,0 +1,41 @@ +WebApp { # Web Application +n1: circle label:"Browser Request" +n2: rectangle label:"Web BFF" +n15: rectangle label:"Render HTML Response" +n16: circle label:"Display Page" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Services.n5.handle(top) [label="Fetch Data"] +n15.handle(right) -> n16.handle(left) +} +MobileApp { # Mobile Application +n3: circle label:"Mobile API Call" +n4: rectangle label:"Mobile BFF" +n17: rectangle label:"Optimized Payload" +n18: circle label:"Render Native UI" +n3.handle(right) -> n4.handle(left) +n4.handle(bottom) -> Services.n5.handle(top) [label="Fetch Data"] +n17.handle(right) -> n18.handle(left) +} +Services { # Shared Microservices +n5: rectangle label:"User Profile Service" +n6: rectangle label:"Content Service" +n7: rectangle label:"Notification Service" +n8: rectangle label:"Analytics Service" +n9: rectangle label:"Prepare Web Payload" +n10: rectangle label:"Prepare Mobile Payload" +n11: rectangle label:"Send Web Response" +n12: rectangle label:"Send Mobile Response" +n13: rectangle label:"Send Push Notification" +n14: rectangle label:"Log Analytics" +n5.handle(right) -> n6.handle(left) [label="User Context"] +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(top) -> WebApp.n15.handle(bottom) [label="Full Payload"] +n11.handle(right) -> n12.handle(left) +n12.handle(top) -> MobileApp.n17.handle(bottom) [label="Compact Payload"] +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Push + Track"] +} diff --git a/uncategorized/architecture/microservices-database-per-service-architecture/README.md b/uncategorized/architecture/microservices-database-per-service-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d0c847a5a87014c87c30e5a465d929bbc9b7a021 --- /dev/null +++ b/uncategorized/architecture/microservices-database-per-service-architecture/README.md @@ -0,0 +1,19 @@ +# Microservices Database-Per-Service Architecture + +A database-per-service architecture diagram where each microservice owns its dedicated data store, with event-driven synchronization via Kafka for cross-service data consistency. This template demonstrates the core microservices data isolation principle, showing how PostgreSQL and MongoDB coexist in a polyglot persistence strategy. Critical for architects enforcing service autonomy while maintaining eventual consistency. + +**Template ID:** `microservices-database-per-service-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 16 +**Lanes:** 4 +**Tags:** [database-per-service, polyglot-persistence, microservices, kafka, event-driven, data-isolation, eventual-consistency, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/microservices-database-per-service-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/microservices-database-per-service-architecture/metadata.json b/uncategorized/architecture/microservices-database-per-service-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..25e534ddfb71c643395156beeaedadf699429506 --- /dev/null +++ b/uncategorized/architecture/microservices-database-per-service-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "microservices-database-per-service-architecture", + "workflow_id": "microservices-database-per-service-architecture", + "title": "Microservices Database-Per-Service Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 16, + "num_lanes": 4, + "tags": [ + "database-per-service", + "polyglot-persistence", + "microservices", + "kafka", + "event-driven", + "data-isolation", + "eventual-consistency", + "architecture-diagram" + ], + "description": "A database-per-service architecture diagram where each microservice owns its dedicated data store, with event-driven synchronization via Kafka for cross-service data consistency. This template demonstrates the core microservices data isolation principle, showing how PostgreSQL and MongoDB coexist in a polyglot persistence strategy. Critical for architects enforcing service autonomy while maintaining eventual consistency.", + "source_path": "", + "repo_path": "uncategorized/architecture/microservices-database-per-service-architecture" +} diff --git a/uncategorized/architecture/microservices-database-per-service-architecture/workflow.fz b/uncategorized/architecture/microservices-database-per-service-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..36f68c8af70e04ccffc4ee4587f5078106f2c4fd --- /dev/null +++ b/uncategorized/architecture/microservices-database-per-service-architecture/workflow.fz @@ -0,0 +1,39 @@ +Gateway { # API Gateway +n1: circle label:"Client Request" +n2: rectangle label:"Route to Service" +n15: rectangle label:"Aggregate Responses" +n16: circle label:"Return to Client" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> UserService.n3.handle(top) [label="User Data"] +n2.handle(bottom) -> OrderService.n7.handle(top) [label="Order Data"] +n15.handle(right) -> n16.handle(left) +} +UserService { # User Service +n3: rectangle label:"Handle User Request" +n4: rectangle label:"Query User DB" +n5: rectangle label:"User PostgreSQL" +n6: rectangle label:"Return User Data" +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="SELECT"] +n5.handle(right) -> n6.handle(left) [label="Result"] +n6.handle(top) -> Gateway.n15.handle(bottom) [label="User JSON"] +} +OrderService { # Order Service +n7: rectangle label:"Handle Order Request" +n8: rectangle label:"Query Order DB" +n9: rectangle label:"Order MongoDB" +n10: rectangle label:"Return Order Data" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="find()"] +n9.handle(right) -> n10.handle(left) [label="Documents"] +n10.handle(top) -> Gateway.n15.handle(bottom) [label="Order JSON"] +} +EventBus { # Event Bus (Kafka) +n11: rectangle label:"Publish Domain Event" +n12: rectangle label:"Event Topic" +n13: rectangle label:"Consume Event" +n14: rectangle label:"Sync Read Model" +n11.handle(right) -> n12.handle(left) [label="UserUpdated"] +n12.handle(right) -> n13.handle(left) [label="Subscribe"] +n13.handle(right) -> n14.handle(left) [label="Update Denormalized"] +} diff --git a/uncategorized/architecture/microservices-decomposition-by-business-capability/README.md b/uncategorized/architecture/microservices-decomposition-by-business-capability/README.md new file mode 100644 index 0000000000000000000000000000000000000000..583b6924fdfdfa5e413aa73eea693afb5fb94b08 --- /dev/null +++ b/uncategorized/architecture/microservices-decomposition-by-business-capability/README.md @@ -0,0 +1,19 @@ +# Microservices Decomposition by Business Capability + +A microservices decomposition architecture diagram organized by business capabilities: Identity, Product Catalog, Pricing, and Order Fulfillment, each with independent data stores and APIs. This template shows how to break a monolith into services aligned with business domains, using a Backend-for-Frontend (BFF) pattern for client-specific aggregation. Useful for architects planning domain-driven microservice boundaries. + +**Template ID:** `microservices-decomposition-by-business-capability` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 5 +**Tags:** [microservices-decomposition, business-capability, bff, domain-driven-design, service-boundaries, monolith-to-microservices, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/microservices-decomposition-by-business-capability` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/microservices-decomposition-by-business-capability/metadata.json b/uncategorized/architecture/microservices-decomposition-by-business-capability/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c06bfb912ba257380a0948f7dbc33c95f3aa58df --- /dev/null +++ b/uncategorized/architecture/microservices-decomposition-by-business-capability/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "microservices-decomposition-by-business-capability", + "workflow_id": "microservices-decomposition-by-business-capability", + "title": "Microservices Decomposition by Business Capability", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 5, + "tags": [ + "microservices-decomposition", + "business-capability", + "bff", + "domain-driven-design", + "service-boundaries", + "monolith-to-microservices", + "architecture-diagram" + ], + "description": "A microservices decomposition architecture diagram organized by business capabilities: Identity, Product Catalog, Pricing, and Order Fulfillment, each with independent data stores and APIs. This template shows how to break a monolith into services aligned with business domains, using a Backend-for-Frontend (BFF) pattern for client-specific aggregation. Useful for architects planning domain-driven microservice boundaries.", + "source_path": "", + "repo_path": "uncategorized/architecture/microservices-decomposition-by-business-capability" +} diff --git a/uncategorized/architecture/microservices-decomposition-by-business-capability/workflow.fz b/uncategorized/architecture/microservices-decomposition-by-business-capability/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..136336144e53704cb9f0177bf7db92bbbaeea33a --- /dev/null +++ b/uncategorized/architecture/microservices-decomposition-by-business-capability/workflow.fz @@ -0,0 +1,45 @@ +Frontend { # Frontend BFF +n1: circle label:"User Action" +n2: rectangle label:"BFF Layer" +n3: rectangle label:"Compose UI Response" +n4: circle label:"Render UI" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Identity.n5.handle(top) [label="Auth Check"] +n3.handle(right) -> n4.handle(left) +} +Identity { # Identity & Access +n5: rectangle label:"Authenticate User" +n6: diamond label:"Authorized?" +n7: rectangle label:"Issue Access Token" +n8: rectangle label:"Deny Access" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) [label="Yes"] +n6.handle(bottom) -> n8.handle(top) [label="No"] +n7.handle(bottom) -> Catalog.n9.handle(top) [label="Token"] +n8.handle(top) -> Frontend.n3.handle(bottom) [label="403"] +} +Catalog { # Product Catalog +n9: rectangle label:"Fetch Product Details" +n10: rectangle label:"Product Database" +n11: rectangle label:"Return Catalog Data" +n9.handle(right) -> n10.handle(left) [label="Query"] +n10.handle(right) -> n11.handle(left) [label="Products"] +n11.handle(bottom) -> Pricing.n12.handle(top) [label="Product IDs"] +n11.handle(top) -> Frontend.n3.handle(bottom) [label="Catalog JSON"] +} +Pricing { # Pricing & Promotions +n12: rectangle label:"Calculate Price" +n13: rectangle label:"Apply Promotions" +n14: rectangle label:"Return Final Price" +n12.handle(right) -> n13.handle(left) [label="Base Price"] +n13.handle(right) -> n14.handle(left) [label="Discounted"] +n14.handle(top) -> Frontend.n3.handle(bottom) [label="Price JSON"] +} +Fulfillment { # Order Fulfillment +n15: rectangle label:"Reserve Inventory" +n16: rectangle label:"Create Shipment" +n17: rectangle label:"Update Order Status" +n15.handle(right) -> n16.handle(left) [label="Reserved"] +n16.handle(right) -> n17.handle(left) [label="Shipped"] +n17.handle(top) -> Frontend.n3.handle(bottom) [label="Status Update"] +} diff --git a/uncategorized/architecture/observability-three-pillars-architecture/README.md b/uncategorized/architecture/observability-three-pillars-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0cadb991ccd163382a513a66a49b102524205b8d --- /dev/null +++ b/uncategorized/architecture/observability-three-pillars-architecture/README.md @@ -0,0 +1,19 @@ +# Observability Three Pillars Architecture + +An observability architecture diagram implementing the three pillars (metrics, traces, logs) with OpenTelemetry SDK instrumentation, OTLP collector pipeline, Prometheus, Jaeger, and Loki backends, Grafana dashboards, SLO/SLI tracking, and PagerDuty alerting integration. This template provides a complete observability stack reference showing how telemetry data flows from application instrumentation through collection, storage, visualization, and incident response. Essential for SRE teams building production monitoring infrastructure. + +**Template ID:** `observability-three-pillars-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [observability, three-pillars, opentelemetry, prometheus, jaeger, loki, grafana, slo-sli, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/observability-three-pillars-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/observability-three-pillars-architecture/metadata.json b/uncategorized/architecture/observability-three-pillars-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..50f347858b471dce6f445a5af03f5f8a74f14a17 --- /dev/null +++ b/uncategorized/architecture/observability-three-pillars-architecture/metadata.json @@ -0,0 +1,27 @@ +{ + "template_id": "observability-three-pillars-architecture", + "workflow_id": "observability-three-pillars-architecture", + "title": "Observability Three Pillars Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "observability", + "three-pillars", + "opentelemetry", + "prometheus", + "jaeger", + "loki", + "grafana", + "slo-sli", + "architecture-diagram" + ], + "description": "An observability architecture diagram implementing the three pillars (metrics, traces, logs) with OpenTelemetry SDK instrumentation, OTLP collector pipeline, Prometheus, Jaeger, and Loki backends, Grafana dashboards, SLO/SLI tracking, and PagerDuty alerting integration. This template provides a complete observability stack reference showing how telemetry data flows from application instrumentation through collection, storage, visualization, and incident response. Essential for SRE teams building production monitoring infrastructure.", + "source_path": "", + "repo_path": "uncategorized/architecture/observability-three-pillars-architecture" +} diff --git a/uncategorized/architecture/observability-three-pillars-architecture/workflow.fz b/uncategorized/architecture/observability-three-pillars-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..33702b40629ef9d5829d01630f709b97fc566fd6 --- /dev/null +++ b/uncategorized/architecture/observability-three-pillars-architecture/workflow.fz @@ -0,0 +1,44 @@ +Application { # Application Services +n1: rectangle label:"Service A" +n2: rectangle label:"Service B" +n3: rectangle label:"Service C" +n4: rectangle label:"OpenTelemetry SDK" +n1.handle(bottom) -> n4.handle(top) [label="Instrument"] +n2.handle(bottom) -> n4.handle(top) [label="Instrument"] +n3.handle(bottom) -> n4.handle(top) [label="Instrument"] +n4.handle(bottom) -> Collector.n5.handle(top) [label="OTLP Export"] +} +Collector { # OpenTelemetry Collector +n5: rectangle label:"Receive Telemetry" +n6: rectangle label:"Process and Batch" +n7: rectangle label:"Export Metrics" +n8: rectangle label:"Export Traces" +n9: rectangle label:"Export Logs" +n5.handle(right) -> n6.handle(left) [label="Pipeline"] +n6.handle(right) -> n7.handle(left) [label="Metrics"] +n6.handle(bottom) -> n8.handle(top) [label="Traces"] +n6.handle(bottom) -> n9.handle(top) [label="Logs"] +n7.handle(bottom) -> Backends.n10.handle(top) [label="Prometheus"] +n8.handle(bottom) -> Backends.n11.handle(top) [label="Jaeger"] +n9.handle(bottom) -> Backends.n12.handle(top) [label="Loki"] +} +Backends { # Observability Backends +n10: rectangle label:"Prometheus (Metrics)" +n11: rectangle label:"Jaeger (Distributed Traces)" +n12: rectangle label:"Loki (Log Aggregation)" +n13: rectangle label:"Alertmanager" +n10.handle(right) -> n13.handle(left) [label="Alert Rules"] +n10.handle(bottom) -> Visualization.n14.handle(top) [label="PromQL"] +n11.handle(bottom) -> Visualization.n14.handle(top) [label="Trace ID"] +n12.handle(bottom) -> Visualization.n14.handle(top) [label="LogQL"] +} +Visualization { # Visualization & Alerting +n14: rectangle label:"Grafana Dashboard" +n15: rectangle label:"SLO/SLI Tracking" +n16: rectangle label:"Incident Response" +n17: rectangle label:"PagerDuty / Slack" +n14.handle(right) -> n15.handle(left) [label="SLO Burn Rate"] +n15.handle(right) -> n16.handle(left) [label="SLO Breach"] +n16.handle(right) -> n17.handle(left) [label="Alert"] +n13.handle(bottom) -> Visualization.n17.handle(top) [label="Fire Alert"] +} diff --git a/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/README.md b/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2280805c57c6fffc5f26bcc111056e5a03deb199 --- /dev/null +++ b/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/README.md @@ -0,0 +1,19 @@ +# Outbox Pattern for Reliable Messaging Architecture + +A transactional outbox architecture diagram where domain writes and event publishing happen in the same database transaction, with a relay process polling the outbox table and publishing events to a message broker with guaranteed delivery. This template solves the dual-write problem where updating a database and publishing an event are not atomic, ensuring exactly-once event delivery without distributed transactions. Critical for event-driven architectures requiring reliable message publishing. + +**Template ID:** `outbox-pattern-reliable-messaging-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 4 +**Tags:** [outbox-pattern, transactional-outbox, reliable-messaging, dual-write, exactly-once, debezium, event-publishing, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/outbox-pattern-reliable-messaging-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/metadata.json b/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..22a87920e045d86a7ced63436c593016af807ff0 --- /dev/null +++ b/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "outbox-pattern-reliable-messaging-architecture", + "workflow_id": "outbox-pattern-reliable-messaging-architecture", + "title": "Outbox Pattern for Reliable Messaging Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 4, + "tags": [ + "outbox-pattern", + "transactional-outbox", + "reliable-messaging", + "dual-write", + "exactly-once", + "debezium", + "event-publishing", + "architecture-diagram" + ], + "description": "A transactional outbox architecture diagram where domain writes and event publishing happen in the same database transaction, with a relay process polling the outbox table and publishing events to a message broker with guaranteed delivery. This template solves the dual-write problem where updating a database and publishing an event are not atomic, ensuring exactly-once event delivery without distributed transactions. Critical for event-driven architectures requiring reliable message publishing.", + "source_path": "", + "repo_path": "uncategorized/architecture/outbox-pattern-reliable-messaging-architecture" +} diff --git a/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/workflow.fz b/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..04d8b9f56c65829306ff62b672ca3141c88378ec --- /dev/null +++ b/uncategorized/architecture/outbox-pattern-reliable-messaging-architecture/workflow.fz @@ -0,0 +1,54 @@ +Application { # Application Service +n1: circle label:"Business Operation" +n2: rectangle label:"Begin Transaction" +n3: rectangle label:"Update Domain Table" +n4: rectangle label:"Insert into Outbox Table" +n9: rectangle label:"Write Confirmed" +n10: rectangle label:"Commit Transaction" +n11: circle label:"Return Success" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Atomic"] +n3.handle(right) -> n4.handle(left) [label="Same TX"] +n4.handle(bottom) -> Database.n5.handle(top) [label="Write"] +n9.handle(right) -> n10.handle(left) [label="Committed"] +n10.handle(right) -> n11.handle(left) +} +Database { # Database +n5: rectangle label:"Domain Table (Orders)" +n6: rectangle label:"Outbox Table (Events)" +n7: rectangle label:"Persist Records" +n8: rectangle label:"Confirm Write" +n12: rectangle label:"Outbox Row: Pending" +n24: rectangle label:"Row Marked Processed" +n5.handle(right) -> n6.handle(left) [label="Same Database"] +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(top) -> Application.n9.handle(bottom) [label="Confirmed"] +n12.handle(bottom) -> Relay.n13.handle(top) [label="Poll"] +} +Relay { # Outbox Relay (Debezium/Poller) +n13: rectangle label:"Poll Outbox Table" +n14: rectangle label:"Read Pending Events" +n15: rectangle label:"Publish to Message Broker" +n16: diamond label:"Published Successfully?" +n17: rectangle label:"Deliver to Consumers" +n18: rectangle label:"Schedule Retry" +n23: rectangle label:"Receive Consumer Ack" +n13.handle(right) -> n14.handle(left) [label="SELECT WHERE status=PENDING"] +n14.handle(right) -> n15.handle(left) [label="Serialize"] +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> n18.handle(top) [label="No"] +n17.handle(bottom) -> Consumers.n19.handle(top) [label="Deliver"] +n23.handle(top) -> Database.n24.handle(bottom) [label="Mark Processed"] +} +Consumers { # Downstream Consumers +n19: rectangle label:"Notification Service" +n20: rectangle label:"Analytics Service" +n21: rectangle label:"Search Index Service" +n22: rectangle label:"Acknowledge Receipt" +n19.handle(right) -> n20.handle(left) [label="OrderCreated"] +n20.handle(right) -> n21.handle(left) [label="OrderCreated"] +n21.handle(right) -> n22.handle(left) +n22.handle(top) -> Relay.n23.handle(bottom) [label="Ack"] +} diff --git a/uncategorized/architecture/rate-limiter-architecture/README.md b/uncategorized/architecture/rate-limiter-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..12ae2fd98f6613718de31db7b57f19d0b129cc68 --- /dev/null +++ b/uncategorized/architecture/rate-limiter-architecture/README.md @@ -0,0 +1,19 @@ +# Rate Limiter Architecture + +A rate limiter architecture diagram implementing the token bucket algorithm with Redis-backed distributed counters, sliding window logs, API key identification, rate limit headers, and multi-node synchronization for consistent enforcement. This template shows how to protect APIs from abuse and ensure fair usage across clients, with proper HTTP 429 responses and Retry-After headers. Essential for API platform teams building production-grade rate limiting infrastructure. + +**Template ID:** `rate-limiter-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [rate-limiter, token-bucket, sliding-window, redis, api-protection, throttling, distributed-rate-limiting, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/rate-limiter-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/rate-limiter-architecture/metadata.json b/uncategorized/architecture/rate-limiter-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e53092d00717ab0b5319151638fe93c774297778 --- /dev/null +++ b/uncategorized/architecture/rate-limiter-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "rate-limiter-architecture", + "workflow_id": "rate-limiter-architecture", + "title": "Rate Limiter Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "rate-limiter", + "token-bucket", + "sliding-window", + "redis", + "api-protection", + "throttling", + "distributed-rate-limiting", + "architecture-diagram" + ], + "description": "A rate limiter architecture diagram implementing the token bucket algorithm with Redis-backed distributed counters, sliding window logs, API key identification, rate limit headers, and multi-node synchronization for consistent enforcement. This template shows how to protect APIs from abuse and ensure fair usage across clients, with proper HTTP 429 responses and Retry-After headers. Essential for API platform teams building production-grade rate limiting infrastructure.", + "source_path": "", + "repo_path": "uncategorized/architecture/rate-limiter-architecture" +} diff --git a/uncategorized/architecture/rate-limiter-architecture/workflow.fz b/uncategorized/architecture/rate-limiter-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b3b6025109b23e7cca4016b2028deddbe190e0ce --- /dev/null +++ b/uncategorized/architecture/rate-limiter-architecture/workflow.fz @@ -0,0 +1,54 @@ +Client { # Client +n1: circle label:"API Request" +n2: rectangle label:"Attach API Key" +n22: rectangle label:"Receive Response" +n23: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> RateLimiter.n3.handle(top) [label="Request"] +n22.handle(right) -> n23.handle(left) +} +RateLimiter { # Rate Limiter (Token Bucket) +n3: rectangle label:"Extract Client Identity" +n4: rectangle label:"Lookup Rate Limit Config" +n5: rectangle label:"Check Token Bucket" +n9: rectangle label:"Receive Bucket Status" +n10: diamond label:"Tokens Available?" +n11: rectangle label:"Consume Token" +n12: rectangle label:"Return 429 Too Many Requests" +n13: rectangle label:"Add Rate Limit Headers" +n14: rectangle label:"Forward to Backend" +n19: rectangle label:"Receive Backend Response" +n20: rectangle label:"Forward Response to Client" +n21: rectangle label:"Send to Client" +n3.handle(right) -> n4.handle(left) [label="API Key / IP"] +n4.handle(right) -> n5.handle(left) [label="100 req/min"] +n5.handle(bottom) -> Store.n6.handle(top) [label="INCR + EXPIRE"] +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n12.handle(top) [label="No"] +n11.handle(right) -> n13.handle(left) [label="Decrement"] +n13.handle(right) -> n14.handle(left) [label="X-RateLimit-Remaining"] +n12.handle(top) -> Client.n22.handle(bottom) [label="429"] +n14.handle(bottom) -> Backend.n15.handle(top) [label="Allowed"] +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(top) -> Client.n22.handle(bottom) [label="200"] +} +Backend { # Backend Service +n15: rectangle label:"Process Request" +n16: rectangle label:"Return Response" +n17: rectangle label:"Send to RateLimiter" +n18: rectangle label:"Forward Response" +n15.handle(right) -> n16.handle(left) [label="Execute"] +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(top) -> RateLimiter.n19.handle(bottom) [label="Backend Response"] +} +Store { # Rate Limit Store (Redis) +n6: rectangle label:"Redis Counter" +n7: rectangle label:"Sliding Window Log" +n8: rectangle label:"Return Bucket Status" +n6.handle(right) -> n7.handle(left) [label="Window Check"] +n7.handle(right) -> n8.handle(left) +n8.handle(top) -> RateLimiter.n9.handle(bottom) [label="Bucket Status"] +} diff --git a/uncategorized/architecture/retry-with-exponential-backoff-architecture/README.md b/uncategorized/architecture/retry-with-exponential-backoff-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e6d4a9fedf37fd55691761dc9d99d693c96adf9d --- /dev/null +++ b/uncategorized/architecture/retry-with-exponential-backoff-architecture/README.md @@ -0,0 +1,19 @@ +# Retry with Exponential Backoff Architecture + +A retry with exponential backoff architecture diagram showing the complete retry policy engine with retryable vs non-retryable error classification, exponential delay calculation with jitter, max retry thresholds, and graceful exhaustion handling. This template models the essential resilience pattern for handling transient failures in distributed systems, preventing thundering herd problems through randomized backoff delays. Foundational for any service-to-service communication in cloud architectures. + +**Template ID:** `retry-with-exponential-backoff-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 17 +**Lanes:** 3 +**Tags:** [retry-pattern, exponential-backoff, jitter, transient-failure, resilience, error-handling, thundering-herd, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/retry-with-exponential-backoff-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/retry-with-exponential-backoff-architecture/metadata.json b/uncategorized/architecture/retry-with-exponential-backoff-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..dbe7318d48b8684e3db96204ac7b7502e34e5b7f --- /dev/null +++ b/uncategorized/architecture/retry-with-exponential-backoff-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "retry-with-exponential-backoff-architecture", + "workflow_id": "retry-with-exponential-backoff-architecture", + "title": "Retry with Exponential Backoff Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 17, + "num_lanes": 3, + "tags": [ + "retry-pattern", + "exponential-backoff", + "jitter", + "transient-failure", + "resilience", + "error-handling", + "thundering-herd", + "architecture-diagram" + ], + "description": "A retry with exponential backoff architecture diagram showing the complete retry policy engine with retryable vs non-retryable error classification, exponential delay calculation with jitter, max retry thresholds, and graceful exhaustion handling. This template models the essential resilience pattern for handling transient failures in distributed systems, preventing thundering herd problems through randomized backoff delays. Foundational for any service-to-service communication in cloud architectures.", + "source_path": "", + "repo_path": "uncategorized/architecture/retry-with-exponential-backoff-architecture" +} diff --git a/uncategorized/architecture/retry-with-exponential-backoff-architecture/workflow.fz b/uncategorized/architecture/retry-with-exponential-backoff-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ad744196d34bf768a541816ade5a3feda49e7e65 --- /dev/null +++ b/uncategorized/architecture/retry-with-exponential-backoff-architecture/workflow.fz @@ -0,0 +1,48 @@ +Caller { # Calling Service +n1: circle label:"Initiate Request" +n2: rectangle label:"Send HTTP Request" +n19: rectangle label:"Receive Response" +n20: circle label:"Request Complete" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> RetryPolicy.n3.handle(top) [label="Execute"] +n19.handle(right) -> n20.handle(left) +} +RetryPolicy { # Retry Policy Engine +n3: rectangle label:"Attempt Request" +n8: diamond label:"Response Status?" +n9: rectangle label:"Return Success" +n10: diamond label:"Retryable Error?" +n11: rectangle label:"Return Permanent Failure" +n12: rectangle label:"Calculate Backoff Delay" +n13: diamond label:"Max Retries Exceeded?" +n14: rectangle label:"Wait with Jitter" +n15: rectangle label:"Return Exhausted Error" +n16: rectangle label:"Forward Success" +n17: rectangle label:"Forward Failure" +n18: rectangle label:"Forward Exhausted" +n3.handle(bottom) -> Target.n4.handle(top) [label="HTTP"] +n8.handle(right) -> n9.handle(left) [label="2xx"] +n8.handle(bottom) -> n10.handle(top) [label="Error"] +n9.handle(right) -> n16.handle(left) +n10.handle(right) -> n12.handle(left) [label="429/503/Timeout"] +n10.handle(bottom) -> n11.handle(top) [label="400/401/404"] +n11.handle(right) -> n17.handle(left) +n12.handle(right) -> n13.handle(left) [label="2^n * base"] +n13.handle(bottom) -> n15.handle(top) [label="Yes"] +n13.handle(right) -> n14.handle(left) [label="No"] +n15.handle(right) -> n18.handle(left) +n16.handle(top) -> Caller.n19.handle(bottom) [label="Success"] +n17.handle(top) -> Caller.n19.handle(bottom) [label="Non-Retryable"] +n18.handle(top) -> Caller.n19.handle(bottom) [label="Max Retries"] +} +Target { # Target Service +n4: rectangle label:"Process Request" +n5: diamond label:"Service Healthy?" +n6: rectangle label:"Return 200 OK" +n7: rectangle label:"Return 503 Unavailable" +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) [label="Yes"] +n5.handle(bottom) -> n7.handle(top) [label="No"] +n6.handle(top) -> RetryPolicy.n8.handle(bottom) [label="Success"] +n7.handle(top) -> RetryPolicy.n8.handle(bottom) [label="Error"] +} diff --git a/uncategorized/architecture/saga-choreography-pattern-architecture/README.md b/uncategorized/architecture/saga-choreography-pattern-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f396cb728bd149998e331f5e6f1f0234b4b552ec --- /dev/null +++ b/uncategorized/architecture/saga-choreography-pattern-architecture/README.md @@ -0,0 +1,19 @@ +# Saga Choreography Pattern Architecture + +A saga choreography architecture diagram where Order, Payment, and Inventory services coordinate through domain events without a central orchestrator, with each service publishing and subscribing to events that drive the transaction forward or trigger compensation. This template models the decentralized saga approach where services autonomously react to events, reducing single points of failure at the cost of increased complexity in tracking saga state. Best for teams preferring service autonomy over centralized control. + +**Template ID:** `saga-choreography-pattern-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 5 +**Tags:** [saga-choreography, event-driven-saga, decentralized, domain-events, compensation, autonomous-services, distributed-transaction, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/saga-choreography-pattern-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/saga-choreography-pattern-architecture/metadata.json b/uncategorized/architecture/saga-choreography-pattern-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7f5f672e8b6129bfcf5eeace81299ee1db8909c9 --- /dev/null +++ b/uncategorized/architecture/saga-choreography-pattern-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "saga-choreography-pattern-architecture", + "workflow_id": "saga-choreography-pattern-architecture", + "title": "Saga Choreography Pattern Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 5, + "tags": [ + "saga-choreography", + "event-driven-saga", + "decentralized", + "domain-events", + "compensation", + "autonomous-services", + "distributed-transaction", + "architecture-diagram" + ], + "description": "A saga choreography architecture diagram where Order, Payment, and Inventory services coordinate through domain events without a central orchestrator, with each service publishing and subscribing to events that drive the transaction forward or trigger compensation. This template models the decentralized saga approach where services autonomously react to events, reducing single points of failure at the cost of increased complexity in tracking saga state. Best for teams preferring service autonomy over centralized control.", + "source_path": "", + "repo_path": "uncategorized/architecture/saga-choreography-pattern-architecture" +} diff --git a/uncategorized/architecture/saga-choreography-pattern-architecture/workflow.fz b/uncategorized/architecture/saga-choreography-pattern-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0469181964b0527bac4ae24068464f4245afc056 --- /dev/null +++ b/uncategorized/architecture/saga-choreography-pattern-architecture/workflow.fz @@ -0,0 +1,61 @@ +OrderService { # Order Service +n1: circle label:"Place Order" +n2: rectangle label:"Create Pending Order" +n3: rectangle label:"Emit OrderCreated" +n19: rectangle label:"Receive Saga Result" +n20: diamond label:"Saga Outcome?" +n21: rectangle label:"Confirm Order" +n22: rectangle label:"Cancel Order" +n23: rectangle label:"Acknowledge to EventBus" +n25: rectangle label:"Send Saga Ack" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) [label="Pending"] +n3.handle(bottom) -> EventBus.n4.handle(top) [label="Publish"] +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) [label="Success"] +n20.handle(bottom) -> n22.handle(top) [label="Failure"] +n21.handle(right) -> n23.handle(left) +n22.handle(right) -> n25.handle(left) +n23.handle(bottom) -> EventBus.n26.handle(top) [label="Success Ack"] +n25.handle(bottom) -> EventBus.n26.handle(top) [label="Failure Ack"] +} +EventBus { # Event Bus +n4: rectangle label:"OrderCreated Topic" +n10: rectangle label:"PaymentProcessed Topic" +n14: rectangle label:"PaymentFailed Topic" +n18: rectangle label:"InventoryReserved Topic" +n24: rectangle label:"Compensation Ack Received" +n26: rectangle label:"Saga Ack Received" +n4.handle(bottom) -> PaymentService.n5.handle(top) [label="Subscribe"] +n10.handle(bottom) -> InventoryService.n11.handle(top) [label="Subscribe"] +n14.handle(bottom) -> InventoryService.n15.handle(top) [label="Subscribe"] +n18.handle(top) -> OrderService.n19.handle(bottom) [label="Notify Success"] +n24.handle(right) -> n26.handle(left) +} +PaymentService { # Payment Service +n5: rectangle label:"Process Payment" +n6: diamond label:"Payment OK?" +n7: rectangle label:"Emit PaymentProcessed" +n8: rectangle label:"Emit PaymentFailed" +n9: rectangle label:"Publish Result" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) [label="Success"] +n6.handle(bottom) -> n8.handle(top) [label="Declined"] +n7.handle(right) -> n9.handle(left) +n9.handle(top) -> EventBus.n10.handle(bottom) [label="Publish"] +n8.handle(top) -> EventBus.n14.handle(bottom) [label="Publish"] +} +InventoryService { # Inventory Service +n11: rectangle label:"Reserve Inventory" +n12: rectangle label:"Emit InventoryReserved" +n13: rectangle label:"Publish Reserved" +n15: rectangle label:"Compensate: Release Stock" +n16: rectangle label:"Stock Released" +n17: rectangle label:"Compensation Complete" +n11.handle(right) -> n12.handle(left) [label="Reserved"] +n12.handle(right) -> n13.handle(left) +n13.handle(top) -> EventBus.n18.handle(bottom) [label="Publish"] +n15.handle(right) -> n16.handle(left) [label="Released"] +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> EventBus.n24.handle(bottom) [label="Compensation Ack"] +} diff --git a/uncategorized/architecture/serverless-event-processing-architecture/README.md b/uncategorized/architecture/serverless-event-processing-architecture/README.md new file mode 100644 index 0000000000000000000000000000000000000000..361a3443dbb7d62a3577eeec40d9ea253a3057db --- /dev/null +++ b/uncategorized/architecture/serverless-event-processing-architecture/README.md @@ -0,0 +1,19 @@ +# Serverless Event Processing Architecture + +A serverless event processing architecture diagram with S3, DynamoDB Streams, API Gateway, and CloudWatch triggers invoking Lambda functions, orchestrated by Step Functions with fan-out via SQS and dead letter queue error handling. This template shows how to build complex event processing pipelines entirely from managed serverless components, with no servers to provision or manage. Ideal for data processing workflows that need elastic scaling and built-in fault tolerance. + +**Template ID:** `serverless-event-processing-architecture` +**Kind:** architecture +**Source domain:** Architecture +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 17 +**Lanes:** 4 +**Tags:** [serverless, event-processing, step-functions, lambda-triggers, sqs, s3-events, dynamodb-streams, architecture-diagram] +**Source path:** `` +**Repo path:** `uncategorized/architecture/serverless-event-processing-architecture` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/architecture/serverless-event-processing-architecture/metadata.json b/uncategorized/architecture/serverless-event-processing-architecture/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..5c843a456b44c95706c4d00df7c08663f8d6bb01 --- /dev/null +++ b/uncategorized/architecture/serverless-event-processing-architecture/metadata.json @@ -0,0 +1,26 @@ +{ + "template_id": "serverless-event-processing-architecture", + "workflow_id": "serverless-event-processing-architecture", + "title": "Serverless Event Processing Architecture", + "kind": "architecture", + "source_domain": "Architecture", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 17, + "num_lanes": 4, + "tags": [ + "serverless", + "event-processing", + "step-functions", + "lambda-triggers", + "sqs", + "s3-events", + "dynamodb-streams", + "architecture-diagram" + ], + "description": "A serverless event processing architecture diagram with S3, DynamoDB Streams, API Gateway, and CloudWatch triggers invoking Lambda functions, orchestrated by Step Functions with fan-out via SQS and dead letter queue error handling. This template shows how to build complex event processing pipelines entirely from managed serverless components, with no servers to provision or manage. Ideal for data processing workflows that need elastic scaling and built-in fault tolerance.", + "source_path": "", + "repo_path": "uncategorized/architecture/serverless-event-processing-architecture" +} diff --git a/uncategorized/architecture/serverless-event-processing-architecture/workflow.fz b/uncategorized/architecture/serverless-event-processing-architecture/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..04ab4e9510e742ea93d4756e374d8bbf7dd14e20 --- /dev/null +++ b/uncategorized/architecture/serverless-event-processing-architecture/workflow.fz @@ -0,0 +1,56 @@ +EventSources { # Event Sources +n1: rectangle label:"S3 Bucket Upload" +n2: rectangle label:"DynamoDB Stream" +n3: rectangle label:"API Gateway Webhook" +n4: rectangle label:"CloudWatch Scheduled Rule" +n24: rectangle label:"Receive Processing Acks" +n1.handle(bottom) -> Triggers.n5.handle(top) [label="ObjectCreated"] +n2.handle(bottom) -> Triggers.n6.handle(top) [label="StreamRecord"] +n3.handle(bottom) -> Triggers.n7.handle(top) [label="POST Event"] +n4.handle(bottom) -> Triggers.n8.handle(top) [label="Cron"] +} +Triggers { # Lambda Triggers +n5: rectangle label:"Image Processing Lambda" +n6: rectangle label:"Data Sync Lambda" +n7: rectangle label:"Webhook Handler Lambda" +n8: rectangle label:"Batch Job Lambda" +n20: rectangle label:"Receive Processing Ack" +n21: rectangle label:"Aggregate Trigger Results" +n22: rectangle label:"Prepare Source Ack" +n23: rectangle label:"Send Source Ack" +n5.handle(bottom) -> Processing.n9.handle(top) [label="Process Image"] +n6.handle(bottom) -> Processing.n11.handle(top) [label="Sync Data"] +n7.handle(bottom) -> Processing.n9.handle(top) [label="Handle Event"] +n8.handle(bottom) -> Processing.n12.handle(top) [label="Run Batch"] +n20.handle(right) -> n21.handle(left) +n21.handle(right) -> n22.handle(left) +n22.handle(right) -> n23.handle(left) +n23.handle(top) -> EventSources.n24.handle(bottom) [label="Triggers Ack"] +} +Processing { # Processing Pipeline +n9: rectangle label:"Step Functions Orchestrator" +n10: diamond label:"Processing Complete?" +n11: rectangle label:"Fan-Out with SQS" +n12: rectangle label:"Transform and Load" +n13: rectangle label:"Error Handler Lambda" +n18: rectangle label:"Receive Storage Ack" +n19: rectangle label:"Send Processing Ack" +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Success"] +n10.handle(bottom) -> n13.handle(top) [label="Failure"] +n11.handle(right) -> n12.handle(left) [label="Parallel"] +n13.handle(bottom) -> Storage.n17.handle(top) [label="DLQ"] +n12.handle(bottom) -> Storage.n14.handle(top) [label="Store"] +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> Triggers.n20.handle(bottom) [label="Processing Ack"] +} +Storage { # Managed Storage +n14: rectangle label:"DynamoDB Table" +n15: rectangle label:"S3 Results Bucket" +n16: rectangle label:"SNS Notification Topic" +n17: rectangle label:"Return Storage Ack" +n14.handle(right) -> n15.handle(left) [label="Archive"] +n15.handle(right) -> n16.handle(left) [label="Notify"] +n16.handle(right) -> n17.handle(left) +n17.handle(top) -> Processing.n18.handle(bottom) [label="Storage Ack"] +} diff --git a/uncategorized/business-operations/cohort-analysis-workflow/README.md b/uncategorized/business-operations/cohort-analysis-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8a2cd2559d3162f5746026408d6193cd7d210374 --- /dev/null +++ b/uncategorized/business-operations/cohort-analysis-workflow/README.md @@ -0,0 +1,19 @@ +# Cohort Analysis Workflow + +Cohort analysis workflow with user segmentation by signup date, retention curve calculation, LTV projection, and behavioral pattern identification. + +**Template ID:** `cohort-analysis-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [cohort-analysis, retention-analysis, user-behavior, ltv, churn-prediction, analytics] +**Source path:** `business-operations/cohort-analysis` +**Repo path:** `uncategorized/business-operations/cohort-analysis-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/cohort-analysis-workflow/metadata.json b/uncategorized/business-operations/cohort-analysis-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d66a88d1a723e9720067e31ba1d3e8fe8db05002 --- /dev/null +++ b/uncategorized/business-operations/cohort-analysis-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "cohort-analysis-workflow", + "workflow_id": "cohort-analysis", + "title": "Cohort Analysis Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "cohort-analysis", + "retention-analysis", + "user-behavior", + "ltv", + "churn-prediction", + "analytics" + ], + "description": "Cohort analysis workflow with user segmentation by signup date, retention curve calculation, LTV projection, and behavioral pattern identification.", + "source_path": "business-operations/cohort-analysis", + "repo_path": "uncategorized/business-operations/cohort-analysis-workflow" +} diff --git a/uncategorized/business-operations/cohort-analysis-workflow/workflow.fz b/uncategorized/business-operations/cohort-analysis-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d5e37ef6c77d3b1c772d483962e6030f11555d9a --- /dev/null +++ b/uncategorized/business-operations/cohort-analysis-workflow/workflow.fz @@ -0,0 +1,39 @@ +Analyst { # Analyst +n1: circle label:"Start" +n2: rectangle label:"Define cohort criteria" +n3: rectangle label:"Set analysis time window" +n4: rectangle label:"Review analysis results" +n5: diamond label:"Insights actionable?" +n6: rectangle label:"Create recommendations report" +n7: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> DataPipeline.n8.handle(top) [label="Extract data"] +n4.handle(right) -> n5.handle(left) +n5.handle(right) -> n6.handle(left) [label="Yes"] +n5.handle(bottom) -> n2.handle(bottom) [label="No - Refine criteria"] +n6.handle(right) -> n7.handle(left) +} +DataPipeline { # Data Pipeline +n8: rectangle label:"Query user events database" +n9: rectangle label:"Group users by signup date" +n10: rectangle label:"Calculate retention metrics" +n11: diamond label:"Data quality check?" +n12: rectangle label:"Flag data anomalies" +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> Analytics.n13.handle(left) [label="Pass"] +n11.handle(bottom) -> n12.handle(top) [label="Fail"] +n12.handle(left) -> n8.handle(bottom) [label="Reprocess"] +} +Analytics { # Analytics Engine +n13: rectangle label:"Compute cohort curves" +n14: rectangle label:"Calculate churn rates" +n15: rectangle label:"Identify behavior patterns" +n16: rectangle label:"Generate visualizations" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(top) -> Analyst.n4.handle(bottom) [label="Results ready"] +} \ No newline at end of file diff --git a/uncategorized/business-operations/community-moderation-workflow/README.md b/uncategorized/business-operations/community-moderation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..de2324cdb02b0ed6d7be83890d2f767fc45eb7c0 --- /dev/null +++ b/uncategorized/business-operations/community-moderation-workflow/README.md @@ -0,0 +1,19 @@ +# Community Moderation Workflow + +Community content moderation workflow with AI auto-flagging, user reports, human review queue, action enforcement, and appeals handling. + +**Template ID:** `community-moderation-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [community-moderation, content-moderation, user-reports, trust-safety, ai-moderation, appeals] +**Source path:** `business-operations/community-moderation` +**Repo path:** `uncategorized/business-operations/community-moderation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/community-moderation-workflow/metadata.json b/uncategorized/business-operations/community-moderation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d95e4c59a7c2c3a282667df238e0273b5c61240f --- /dev/null +++ b/uncategorized/business-operations/community-moderation-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "community-moderation-workflow", + "workflow_id": "community-moderation", + "title": "Community Moderation Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "community-moderation", + "content-moderation", + "user-reports", + "trust-safety", + "ai-moderation", + "appeals" + ], + "description": "Community content moderation workflow with AI auto-flagging, user reports, human review queue, action enforcement, and appeals handling.", + "source_path": "business-operations/community-moderation", + "repo_path": "uncategorized/business-operations/community-moderation-workflow" +} diff --git a/uncategorized/business-operations/community-moderation-workflow/workflow.fz b/uncategorized/business-operations/community-moderation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..dc20f182d68f95b04189612ac4787d7acfb3f18f --- /dev/null +++ b/uncategorized/business-operations/community-moderation-workflow/workflow.fz @@ -0,0 +1,44 @@ +User { # User +n1: circle label:"Start" +n2: rectangle label:"Report content or user" +n3: rectangle label:"Receive moderation outcome" +n4: diamond label:"Appeal decision?" +n5: rectangle label:"Submit appeal with reason" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> AutoMod.n7.handle(top) [label="Flag content"] +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n6.handle(left) [label="No"] +n4.handle(bottom) -> n5.handle(top) [label="Yes"] +n5.handle(bottom) -> HumanMod.n15.handle(top) [label="Review appeal"] +} +AutoMod { # Auto Moderation +n7: rectangle label:"Scan content with AI" +n8: diamond label:"Violates policy?" +n9: rectangle label:"Auto-remove content" +n10: rectangle label:"Mark as safe" +n11: diamond label:"Confidence high?" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n11.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n11.handle(right) -> n9.handle(left) [label="Yes"] +n11.handle(bottom) -> HumanMod.n12.handle(top) [label="No - Escalate"] +n9.handle(top) -> User.n3.handle(bottom) [label="Removed"] +n10.handle(top) -> User.n3.handle(bottom) [label="Approved"] +} +HumanMod { # Human Moderator +n12: rectangle label:"Review flagged content" +n13: diamond label:"Policy violation?" +n14: rectangle label:"Apply appropriate action" +n15: rectangle label:"Review appeal case" +n16: diamond label:"Overturn decision?" +n17: rectangle label:"Restore content" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Yes"] +n13.handle(bottom) -> AutoMod.n10.handle(bottom) [label="No"] +n14.handle(top) -> User.n3.handle(bottom) [label="Action taken"] +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> User.n6.handle(top) [label="No - Upheld"] +n17.handle(top) -> User.n3.handle(bottom) [label="Restored"] +} \ No newline at end of file diff --git a/uncategorized/business-operations/email-campaign-workflow/README.md b/uncategorized/business-operations/email-campaign-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2f703e12987212d25c4e7ef0f4dd540225b59545 --- /dev/null +++ b/uncategorized/business-operations/email-campaign-workflow/README.md @@ -0,0 +1,19 @@ +# Email Campaign Workflow + +Email marketing campaign workflow with audience segmentation, A/B testing, send scheduling, deliverability monitoring, and engagement analytics. + +**Template ID:** `email-campaign-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [email-campaign, marketing-automation, mailchimp, segmentation, a-b-testing, deliverability] +**Source path:** `business-operations/email-campaign` +**Repo path:** `uncategorized/business-operations/email-campaign-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/email-campaign-workflow/metadata.json b/uncategorized/business-operations/email-campaign-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9d316d448a62ef54dac3b0ffa2566002a0a5d75c --- /dev/null +++ b/uncategorized/business-operations/email-campaign-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "email-campaign-workflow", + "workflow_id": "email-campaign", + "title": "Email Campaign Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "email-campaign", + "marketing-automation", + "mailchimp", + "segmentation", + "a-b-testing", + "deliverability" + ], + "description": "Email marketing campaign workflow with audience segmentation, A/B testing, send scheduling, deliverability monitoring, and engagement analytics.", + "source_path": "business-operations/email-campaign", + "repo_path": "uncategorized/business-operations/email-campaign-workflow" +} diff --git a/uncategorized/business-operations/email-campaign-workflow/workflow.fz b/uncategorized/business-operations/email-campaign-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..2b639321a50caeb09f42d3318e6b17df0a33b0a8 --- /dev/null +++ b/uncategorized/business-operations/email-campaign-workflow/workflow.fz @@ -0,0 +1,49 @@ +Marketer { # Marketer + n1: circle label:"Start" + n2: rectangle label:"Define campaign objectives" + n3: rectangle label:"Select target audience" + n4: rectangle label:"Create email content" + n5: rectangle label:"Review campaign analytics" + n6: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> CRM.n7.handle(top) [label="Query segments"] + n4.handle(bottom) -> EmailPlatform.n11.handle(top) [label="Upload content"] + n5.handle(right) -> n6.handle(left) +} +CRM { # CRM System + n7: rectangle label:"Filter subscribers by criteria" + n8: diamond label:"List size sufficient?" + n9: rectangle label:"Export recipient list" + n10: rectangle label:"Expand criteria" + n7.handle(right) -> n8.handle(left) + n8.handle(right) -> n9.handle(left) [label="Yes"] + n8.handle(bottom) -> n10.handle(top) [label="No"] + n10.handle(left) -> n7.handle(bottom) [label="Retry"] + n9.handle(top) -> Marketer.n4.handle(bottom) [label="List ready"] +} +EmailPlatform { # Email Platform + n11: rectangle label:"Validate email template" + n12: rectangle label:"Schedule send time" + n13: diamond label:"A/B test enabled?" + n14: rectangle label:"Split audience randomly" + n15: rectangle label:"Send to full list" + n16: rectangle label:"Queue emails for delivery" + n11.handle(right) -> n12.handle(left) + n12.handle(right) -> n13.handle(left) + n13.handle(right) -> n14.handle(left) [label="Yes"] + n13.handle(bottom) -> n15.handle(top) [label="No"] + n14.handle(right) -> n16.handle(left) + n15.handle(right) -> n16.handle(top) + n16.handle(bottom) -> Analytics.n17.handle(top) [label="Sending"] +} +Analytics { # Analytics + n17: rectangle label:"Track delivery rates" + n18: rectangle label:"Monitor open rates" + n19: rectangle label:"Record click-through rates" + n20: rectangle label:"Calculate conversion metrics" + n17.handle(right) -> n18.handle(left) + n18.handle(right) -> n19.handle(left) + n19.handle(right) -> n20.handle(left) + n20.handle(top) -> Marketer.n5.handle(bottom) [label="Report ready"] +} \ No newline at end of file diff --git a/uncategorized/business-operations/in-app-message-workflow/README.md b/uncategorized/business-operations/in-app-message-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9182a4c643ccf72056a6d56ae9917c50b254278 --- /dev/null +++ b/uncategorized/business-operations/in-app-message-workflow/README.md @@ -0,0 +1,19 @@ +# In App Message Workflow + +In-app messaging workflow with trigger conditions, audience targeting, message display, user interaction tracking, and conversion measurement. + +**Template ID:** `in-app-message-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [in-app-message, product-tours, tooltips, announcements, user-engagement, intercom] +**Source path:** `business-operations/in-app-message` +**Repo path:** `uncategorized/business-operations/in-app-message-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/in-app-message-workflow/metadata.json b/uncategorized/business-operations/in-app-message-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..803b18c00ef708544884b51da7674ffd805e6df3 --- /dev/null +++ b/uncategorized/business-operations/in-app-message-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "in-app-message-workflow", + "workflow_id": "in-app-message", + "title": "In App Message Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "in-app-message", + "product-tours", + "tooltips", + "announcements", + "user-engagement", + "intercom" + ], + "description": "In-app messaging workflow with trigger conditions, audience targeting, message display, user interaction tracking, and conversion measurement.", + "source_path": "business-operations/in-app-message", + "repo_path": "uncategorized/business-operations/in-app-message-workflow" +} diff --git a/uncategorized/business-operations/in-app-message-workflow/workflow.fz b/uncategorized/business-operations/in-app-message-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9fe4cb8ad7365958c7a6f3c77fafd430df745e35 --- /dev/null +++ b/uncategorized/business-operations/in-app-message-workflow/workflow.fz @@ -0,0 +1,46 @@ +n8nTrigger { # n8n Webhook Trigger + n1: circle label:"Start" + n2: rectangle label:"Receive user event webhook" + n3: rectangle label:"Parse event payload" + n4: diamond label:"Event type?" + n5: rectangle label:"Route to onboarding flow" + n6: rectangle label:"Route to engagement flow" + n7: rectangle label:"Route to retention flow" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> n5.handle(left) [label="signup"] + n4.handle(bottom) -> n6.handle(top) [label="feature_used"] + n4.handle(left) -> n7.handle(top) [label="inactive"] + n5.handle(bottom) -> Segmentation.n8.handle(top) [label="Check segment"] + n6.handle(bottom) -> Segmentation.n8.handle(top) [label="Check segment"] + n7.handle(bottom) -> Segmentation.n8.handle(top) [label="Check segment"] +} +Segmentation { # n8n IF Node + n8: rectangle label:"Fetch user profile from DB" + n9: diamond label:"User segment?" + n10: rectangle label:"Select premium template" + n11: rectangle label:"Select standard template" + n12: rectangle label:"Select trial template" + n8.handle(right) -> n9.handle(left) + n9.handle(right) -> n10.handle(left) [label="Premium"] + n9.handle(bottom) -> n11.handle(top) [label="Standard"] + n9.handle(left) -> n12.handle(top) [label="Trial"] + n10.handle(bottom) -> Delivery.n13.handle(top) [label="Template"] + n11.handle(bottom) -> Delivery.n13.handle(top) [label="Template"] + n12.handle(bottom) -> Delivery.n13.handle(top) [label="Template"] +} +Delivery { # n8n HTTP Request + n13: rectangle label:"Personalize message content" + n14: rectangle label:"POST to Intercom API" + n15: diamond label:"Delivery successful?" + n16: rectangle label:"Log to Google Sheets" + n17: rectangle label:"Send Slack alert" + n18: circle label:"End" + n13.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> n16.handle(left) [label="Yes"] + n15.handle(bottom) -> n17.handle(top) [label="No"] + n16.handle(right) -> n18.handle(left) + n17.handle(right) -> n18.handle(top) +} \ No newline at end of file diff --git a/uncategorized/business-operations/personalization-engine-workflow/README.md b/uncategorized/business-operations/personalization-engine-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..26dad079180f8c68f302dc6080615c69c9e1d880 --- /dev/null +++ b/uncategorized/business-operations/personalization-engine-workflow/README.md @@ -0,0 +1,19 @@ +# Personalization Engine Workflow + +Make.com automation scenario for real-time personalization using Segment events, ML recommendation API, and Braze campaign delivery across email and push channels. + +**Template ID:** `personalization-engine-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 20 +**Lanes:** 3 +**Tags:** [make-com, personalization, segment, braze, ml-recommendations, content-delivery, marketing-automation] +**Source path:** `business-operations/personalization-engine` +**Repo path:** `uncategorized/business-operations/personalization-engine-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/personalization-engine-workflow/metadata.json b/uncategorized/business-operations/personalization-engine-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..95ec9445e4496d7771d29297438fb1ef3c2d8771 --- /dev/null +++ b/uncategorized/business-operations/personalization-engine-workflow/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "personalization-engine-workflow", + "workflow_id": "personalization-engine", + "title": "Personalization Engine Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 20, + "num_lanes": 3, + "tags": [ + "make-com", + "personalization", + "segment", + "braze", + "ml-recommendations", + "content-delivery", + "marketing-automation" + ], + "description": "Make.com automation scenario for real-time personalization using Segment events, ML recommendation API, and Braze campaign delivery across email and push channels.", + "source_path": "business-operations/personalization-engine", + "repo_path": "uncategorized/business-operations/personalization-engine-workflow" +} diff --git a/uncategorized/business-operations/personalization-engine-workflow/workflow.fz b/uncategorized/business-operations/personalization-engine-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b9556607f20dedd069012dc8081639f4729437a5 --- /dev/null +++ b/uncategorized/business-operations/personalization-engine-workflow/workflow.fz @@ -0,0 +1,49 @@ +MakeScenario { # Make.com Scenario +n1: circle label:"Start" +n2: rectangle label:"Watch Segment user events" +n3: rectangle label:"Parse user properties" +n4: diamond label:"Event type?" +n5: rectangle label:"Handle page view" +n6: rectangle label:"Handle purchase" +n7: rectangle label:"Handle signup" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="page"] +n4.handle(bottom) -> n6.handle(top) [label="purchase"] +n4.handle(left) -> n7.handle(top) [label="signup"] +n5.handle(bottom) -> MLModel.n8.handle(top) [label="Predict"] +n6.handle(bottom) -> MLModel.n8.handle(top) [label="Predict"] +n7.handle(bottom) -> MLModel.n8.handle(top) [label="Predict"] +} +MLModel { # Make.com HTTP Module +n8: rectangle label:"POST to recommendation API" +n9: rectangle label:"Parse ML predictions" +n10: diamond label:"Confidence score?" +n11: rectangle label:"Use personalized content" +n12: rectangle label:"Use default content" +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="> 0.7"] +n10.handle(bottom) -> n12.handle(top) [label="<= 0.7"] +n11.handle(bottom) -> ContentDelivery.n13.handle(top) [label="Personalized"] +n12.handle(bottom) -> ContentDelivery.n13.handle(top) [label="Default"] +} +ContentDelivery { # Make.com Iterator +n13: rectangle label:"Fetch content variants" +n14: rectangle label:"Select best variant" +n15: rectangle label:"Update Braze user profile" +n16: rectangle label:"Trigger Braze campaign" +n17: diamond label:"Channel preference?" +n18: rectangle label:"Send via email" +n19: rectangle label:"Send via push" +n20: circle label:"End" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="email"] +n17.handle(bottom) -> n19.handle(top) [label="push"] +n18.handle(right) -> n20.handle(left) +n19.handle(right) -> n20.handle(top) +} \ No newline at end of file diff --git a/uncategorized/business-operations/push-notification-workflow/README.md b/uncategorized/business-operations/push-notification-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bf4149f309cbdbb4d6b7546f3bb74d387b2581b2 --- /dev/null +++ b/uncategorized/business-operations/push-notification-workflow/README.md @@ -0,0 +1,19 @@ +# Push Notification Workflow + +Mobile push notification workflow with audience targeting, platform routing (iOS/Android), delivery tracking, and engagement analytics. + +**Template ID:** `push-notification-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [push-notification, mobile-engagement, firebase-fcm, apns, segmentation, deep-linking] +**Source path:** `business-operations/push-notification` +**Repo path:** `uncategorized/business-operations/push-notification-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/push-notification-workflow/metadata.json b/uncategorized/business-operations/push-notification-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..fc25bc05e42cf5bed319ba678adcab908193e0ab --- /dev/null +++ b/uncategorized/business-operations/push-notification-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "push-notification-workflow", + "workflow_id": "push-notification", + "title": "Push Notification Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "push-notification", + "mobile-engagement", + "firebase-fcm", + "apns", + "segmentation", + "deep-linking" + ], + "description": "Mobile push notification workflow with audience targeting, platform routing (iOS/Android), delivery tracking, and engagement analytics.", + "source_path": "business-operations/push-notification", + "repo_path": "uncategorized/business-operations/push-notification-workflow" +} diff --git a/uncategorized/business-operations/push-notification-workflow/workflow.fz b/uncategorized/business-operations/push-notification-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0f167d338d723d757d30007d247c8129c668a5ac --- /dev/null +++ b/uncategorized/business-operations/push-notification-workflow/workflow.fz @@ -0,0 +1,46 @@ +MakeWebhook { # Make.com Webhook + n1: circle label:"Start" + n2: rectangle label:"Receive trigger from Airtable" + n3: rectangle label:"Get record details" + n4: diamond label:"Notification type?" + n5: rectangle label:"Format promotional message" + n6: rectangle label:"Format transactional message" + n7: rectangle label:"Format reminder message" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> n5.handle(left) [label="promo"] + n4.handle(bottom) -> n6.handle(top) [label="transaction"] + n4.handle(left) -> n7.handle(top) [label="reminder"] + n5.handle(bottom) -> OneSignal.n8.handle(top) [label="Send"] + n6.handle(bottom) -> OneSignal.n8.handle(top) [label="Send"] + n7.handle(bottom) -> OneSignal.n8.handle(top) [label="Send"] +} +OneSignal { # Make.com OneSignal Module + n8: rectangle label:"Create notification payload" + n9: rectangle label:"Set target segments" + n10: rectangle label:"POST to OneSignal API" + n11: diamond label:"API response OK?" + n12: rectangle label:"Extract notification ID" + n13: rectangle label:"Log error details" + n8.handle(right) -> n9.handle(left) + n9.handle(right) -> n10.handle(left) + n10.handle(right) -> n11.handle(left) + n11.handle(right) -> n12.handle(left) [label="200"] + n11.handle(bottom) -> n13.handle(top) [label="Error"] + n12.handle(bottom) -> Analytics.n14.handle(top) [label="Track"] + n13.handle(bottom) -> Analytics.n19.handle(top) [label="Alert"] +} +Analytics { # Make.com Data Store + n14: rectangle label:"Update Airtable record" + n15: rectangle label:"Increment send counter" + n16: rectangle label:"Calculate delivery rate" + n17: rectangle label:"Update Google Analytics" + n18: circle label:"End" + n19: rectangle label:"Send Slack error alert" + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> n16.handle(left) + n16.handle(right) -> n17.handle(left) + n17.handle(right) -> n18.handle(left) + n19.handle(right) -> n18.handle(top) +} \ No newline at end of file diff --git a/uncategorized/business-operations/referral-program-workflow/README.md b/uncategorized/business-operations/referral-program-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b3edf168fdc0c6abd0cb8fd1e1515d0cd4a745f8 --- /dev/null +++ b/uncategorized/business-operations/referral-program-workflow/README.md @@ -0,0 +1,19 @@ +# Referral Program Workflow + +Customer referral program workflow with unique link generation, referral tracking, conversion validation, and dual-sided reward fulfillment. + +**Template ID:** `referral-program-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [referral-program, viral-growth, referral-tracking, reward-fulfillment, affiliate, word-of-mouth] +**Source path:** `business-operations/referral-program` +**Repo path:** `uncategorized/business-operations/referral-program-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/referral-program-workflow/metadata.json b/uncategorized/business-operations/referral-program-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..2def1c180c9d49c60f0b22ec401eebb3e2bf862e --- /dev/null +++ b/uncategorized/business-operations/referral-program-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "referral-program-workflow", + "workflow_id": "referral-program", + "title": "Referral Program Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "referral-program", + "viral-growth", + "referral-tracking", + "reward-fulfillment", + "affiliate", + "word-of-mouth" + ], + "description": "Customer referral program workflow with unique link generation, referral tracking, conversion validation, and dual-sided reward fulfillment.", + "source_path": "business-operations/referral-program", + "repo_path": "uncategorized/business-operations/referral-program-workflow" +} diff --git a/uncategorized/business-operations/referral-program-workflow/workflow.fz b/uncategorized/business-operations/referral-program-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..49542fe519c975886cab25004938591e4e0f0424 --- /dev/null +++ b/uncategorized/business-operations/referral-program-workflow/workflow.fz @@ -0,0 +1,41 @@ +Referrer { # Referrer + n1: circle label:"Start" + n2: rectangle label:"Generate referral link" + n3: rectangle label:"Share link with friend" + n4: rectangle label:"Receive reward notification" + n5: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> ReferralSystem.n6.handle(top) [label="Create link"] + n3.handle(bottom) -> ReferralSystem.n9.handle(top) [label="Track click"] + n4.handle(right) -> n5.handle(left) +} +ReferralSystem { # Referral System + n6: rectangle label:"Generate unique tracking code" + n7: rectangle label:"Store referrer association" + n8: rectangle label:"Return shareable URL" + n9: rectangle label:"Log referral click" + n10: diamond label:"New user signup?" + n11: rectangle label:"Attribute to referrer" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n8.handle(top) -> Referrer.n3.handle(bottom) [label="Link ready"] + n9.handle(right) -> n10.handle(left) + n10.handle(right) -> n11.handle(left) [label="Yes"] + n10.handle(bottom) -> Referrer.n5.handle(top) [label="No - Existing user"] + n11.handle(bottom) -> Rewards.n12.handle(top) [label="Validate"] +} +Rewards { # Rewards Engine + n12: rectangle label:"Check eligibility rules" + n13: diamond label:"Qualifies for reward?" + n14: rectangle label:"Calculate reward amount" + n15: rectangle label:"Credit referrer account" + n16: rectangle label:"Credit referee bonus" + n17: rectangle label:"Log rejection reason" + n12.handle(right) -> n13.handle(left) + n13.handle(right) -> n14.handle(left) [label="Yes"] + n13.handle(bottom) -> n17.handle(top) [label="No"] + n14.handle(right) -> n15.handle(left) + n15.handle(right) -> n16.handle(left) + n16.handle(top) -> Referrer.n4.handle(bottom) [label="Rewards issued"] + n17.handle(top) -> Referrer.n5.handle(bottom) [label="Ineligible"] +} \ No newline at end of file diff --git a/uncategorized/business-operations/search-optimization-workflow/README.md b/uncategorized/business-operations/search-optimization-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..18703a07df984a148453d751ff8b317e03c31c78 --- /dev/null +++ b/uncategorized/business-operations/search-optimization-workflow/README.md @@ -0,0 +1,19 @@ +# Search Optimization Workflow + +Search optimization workflow with query analysis, relevance tuning, synonym management, click-through tracking, and A/B testing of ranking algorithms. + +**Template ID:** `search-optimization-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [search-optimization, elasticsearch, relevance-tuning, query-analysis, algolia, search-analytics] +**Source path:** `business-operations/search-optimization` +**Repo path:** `uncategorized/business-operations/search-optimization-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/search-optimization-workflow/metadata.json b/uncategorized/business-operations/search-optimization-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4eec1ff044749b988f9212b2c18172c454e29fd1 --- /dev/null +++ b/uncategorized/business-operations/search-optimization-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "search-optimization-workflow", + "workflow_id": "search-optimization", + "title": "Search Optimization Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "search-optimization", + "elasticsearch", + "relevance-tuning", + "query-analysis", + "algolia", + "search-analytics" + ], + "description": "Search optimization workflow with query analysis, relevance tuning, synonym management, click-through tracking, and A/B testing of ranking algorithms.", + "source_path": "business-operations/search-optimization", + "repo_path": "uncategorized/business-operations/search-optimization-workflow" +} diff --git a/uncategorized/business-operations/search-optimization-workflow/workflow.fz b/uncategorized/business-operations/search-optimization-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9d77cc97a9c71d1d2dcd71d0b955f0b573f4c00a --- /dev/null +++ b/uncategorized/business-operations/search-optimization-workflow/workflow.fz @@ -0,0 +1,41 @@ +n8nTrigger { # n8n Schedule Trigger + n1: circle label:"Start" + n2: rectangle label:"Trigger weekly SEO audit" + n3: rectangle label:"Fetch sitemap URLs" + n4: rectangle label:"Generate SEO report" + n5: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> Crawler.n6.handle(top) [label="Crawl"] + n4.handle(right) -> n5.handle(left) +} +Crawler { # n8n HTTP Request + n6: rectangle label:"Crawl each page" + n7: rectangle label:"Extract meta tags" + n8: rectangle label:"Check page speed" + n9: diamond label:"Issues found?" + n10: rectangle label:"Log SEO issues" + n11: rectangle label:"Mark page healthy" + n6.handle(right) -> n7.handle(left) + n7.handle(right) -> n8.handle(left) + n8.handle(right) -> n9.handle(left) + n9.handle(right) -> n10.handle(left) [label="Yes"] + n9.handle(bottom) -> n11.handle(top) [label="No"] + n10.handle(bottom) -> Analysis.n12.handle(top) [label="Analyze"] + n11.handle(bottom) -> Analysis.n12.handle(top) [label="Analyze"] +} +Analysis { # n8n Function Node + n12: rectangle label:"Calculate SEO score" + n13: rectangle label:"Compare to competitors" + n14: diamond label:"Score improved?" + n15: rectangle label:"Generate recommendations" + n16: rectangle label:"Flag regression" + n17: rectangle label:"Send Slack notification" + n12.handle(right) -> n13.handle(left) + n13.handle(right) -> n14.handle(left) + n14.handle(right) -> n15.handle(left) [label="Yes"] + n14.handle(bottom) -> n16.handle(top) [label="No"] + n15.handle(right) -> n17.handle(left) + n16.handle(right) -> n17.handle(top) + n17.handle(top) -> n8nTrigger.n4.handle(bottom) [label="Complete"] +} \ No newline at end of file diff --git a/uncategorized/business-operations/user-segmentation-workflow/README.md b/uncategorized/business-operations/user-segmentation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5c95aca6a92f6a4b0a8e76fd0b15c12582df0310 --- /dev/null +++ b/uncategorized/business-operations/user-segmentation-workflow/README.md @@ -0,0 +1,19 @@ +# User Segmentation Workflow + +User segmentation workflow with attribute collection, behavioral event tracking, segment rule definition, dynamic membership, and downstream sync. + +**Template ID:** `user-segmentation-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [user-segmentation, audience-targeting, behavioral-cohorts, customer-segments, segment, marketing-automation] +**Source path:** `business-operations/user-segmentation` +**Repo path:** `uncategorized/business-operations/user-segmentation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/user-segmentation-workflow/metadata.json b/uncategorized/business-operations/user-segmentation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6c6ba7d2b225172f81144677ec0f34639e280657 --- /dev/null +++ b/uncategorized/business-operations/user-segmentation-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "user-segmentation-workflow", + "workflow_id": "user-segmentation", + "title": "User Segmentation Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "user-segmentation", + "audience-targeting", + "behavioral-cohorts", + "customer-segments", + "segment", + "marketing-automation" + ], + "description": "User segmentation workflow with attribute collection, behavioral event tracking, segment rule definition, dynamic membership, and downstream sync.", + "source_path": "business-operations/user-segmentation", + "repo_path": "uncategorized/business-operations/user-segmentation-workflow" +} diff --git a/uncategorized/business-operations/user-segmentation-workflow/workflow.fz b/uncategorized/business-operations/user-segmentation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b68d500b2db2ffc697ef8ae25bf8f6a1d5031f4d --- /dev/null +++ b/uncategorized/business-operations/user-segmentation-workflow/workflow.fz @@ -0,0 +1,20 @@ +customer { # Customer + n1: circle label:"Start User Segmentation" + n3: diamond label:"Review User Segmentation details" + n5: rectangle label:"Update records for User Segmentation" + n7: circle label:"End User Segmentation" + + n1.handle(bottom) -> agent.n2.handle(top) [label="Success"] + n3.handle(bottom) -> agent.n4.handle(top) + n3.handle(right) -> agent.n2.handle(right) [label="Retry/Rejected"] + n5.handle(bottom) -> agent.n6.handle(top) +} +agent { # Agent + n2: rectangle label:"Receive User Segmentation request" + n4: rectangle label:"Make User Segmentation decision" + n6: rectangle label:"Continue User Segmentation process" + + n2.handle(bottom) -> customer.n3.handle(top) + n4.handle(bottom) -> customer.n5.handle(top) [label="Valid"] + n6.handle(bottom) -> customer.n7.handle(top) +} \ No newline at end of file diff --git a/uncategorized/business-operations/webhook-integration-workflow/README.md b/uncategorized/business-operations/webhook-integration-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..05aba10ce8da7d68b461c17939173dfc541ef7e6 --- /dev/null +++ b/uncategorized/business-operations/webhook-integration-workflow/README.md @@ -0,0 +1,19 @@ +# Webhook Integration Workflow + +Webhook integration workflow with endpoint registration, payload signing, delivery attempt, retry with backoff, and delivery status tracking. + +**Template ID:** `webhook-integration-workflow` +**Kind:** workflow +**Source domain:** business-operations +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [webhook, event-driven, http-callback, integration, retry-logic, payload-signing] +**Source path:** `business-operations/webhook-integration` +**Repo path:** `uncategorized/business-operations/webhook-integration-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/business-operations/webhook-integration-workflow/metadata.json b/uncategorized/business-operations/webhook-integration-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..eac3ec7605047f3ef22a09c453718572888be6b0 --- /dev/null +++ b/uncategorized/business-operations/webhook-integration-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "webhook-integration-workflow", + "workflow_id": "webhook-integration", + "title": "Webhook Integration Workflow", + "kind": "workflow", + "source_domain": "business-operations", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "webhook", + "event-driven", + "http-callback", + "integration", + "retry-logic", + "payload-signing" + ], + "description": "Webhook integration workflow with endpoint registration, payload signing, delivery attempt, retry with backoff, and delivery status tracking.", + "source_path": "business-operations/webhook-integration", + "repo_path": "uncategorized/business-operations/webhook-integration-workflow" +} diff --git a/uncategorized/business-operations/webhook-integration-workflow/workflow.fz b/uncategorized/business-operations/webhook-integration-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ac57bbdad3ad283d943af669d8c5a0b96b9fe8b7 --- /dev/null +++ b/uncategorized/business-operations/webhook-integration-workflow/workflow.fz @@ -0,0 +1,55 @@ +ExternalService { # External Service + n1: circle label:"Start" + n2: rectangle label:"Event occurs" + n3: rectangle label:"Prepare webhook payload" + n4: rectangle label:"Send HTTP POST request" + n5: diamond label:"Response 2xx?" + n6: rectangle label:"Log successful delivery" + n7: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(right) -> n4.handle(left) + n4.handle(bottom) -> WebhookReceiver.n8.handle(top) [label="POST /webhook"] + n5.handle(right) -> n6.handle(left) [label="Yes"] + n5.handle(bottom) -> RetryQueue.n15.handle(top) [label="No"] + n6.handle(right) -> n7.handle(left) +} + +WebhookReceiver { # Webhook Receiver + n8: rectangle label:"Validate signature header" + n9: diamond label:"Signature valid?" + n10: rectangle label:"Parse JSON payload" + n11: rectangle label:"Acknowledge with 200 OK" + n12: rectangle label:"Return 401 Unauthorized" + n13: rectangle label:"Queue for async processing" + n14: rectangle label:"Return 400 Bad Request" + n8.handle(right) -> n9.handle(left) + n9.handle(right) -> n10.handle(left) [label="Yes"] + n9.handle(bottom) -> n12.handle(top) [label="No"] + n10.handle(right) -> n11.handle(left) + n11.handle(right) -> n13.handle(left) + n12.handle(top) -> ExternalService.n5.handle(bottom) [label="401"] + n13.handle(bottom) -> EventProcessor.n18.handle(top) [label="Process"] + n14.handle(top) -> ExternalService.n5.handle(bottom) [label="400"] +} + +RetryQueue { # Retry Queue + n15: rectangle label:"Add to retry queue" + n16: rectangle label:"Wait with backoff" + n17: rectangle label:"Retry delivery" + n15.handle(right) -> n16.handle(left) + n16.handle(right) -> n17.handle(left) + n17.handle(top) -> ExternalService.n4.handle(bottom) [label="Retry"] + loop [retry up to 5 times] n15 n16 n17 +} + +EventProcessor { # Event Processor + n18: rectangle label:"Deserialize event data" + n19: rectangle label:"Route to handler" + n20: rectangle label:"Execute business logic" + n21: rectangle label:"Update local state" + n18.handle(right) -> n19.handle(left) + n19.handle(right) -> n20.handle(left) + n20.handle(right) -> n21.handle(left) + n21.handle(top) -> ExternalService.n7.handle(bottom) [label="Complete"] +} \ No newline at end of file diff --git a/uncategorized/devops/chaos-engineering-workflow/README.md b/uncategorized/devops/chaos-engineering-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dec9dde1cfff1a287ee73f7069a8eac3d94a49ef --- /dev/null +++ b/uncategorized/devops/chaos-engineering-workflow/README.md @@ -0,0 +1,19 @@ +# Chaos Engineering Workflow + +Chaos engineering workflow with hypothesis definition, steady-state monitoring, controlled fault injection, blast radius limitation, and resilience validation. + +**Template ID:** `chaos-engineering-workflow` +**Kind:** workflow +**Source domain:** devops +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [chaos-engineering, fault-injection, resilience-testing, game-day, blast-radius, steady-state] +**Source path:** `devops/chaos-engineering` +**Repo path:** `uncategorized/devops/chaos-engineering-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/devops/chaos-engineering-workflow/metadata.json b/uncategorized/devops/chaos-engineering-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..588fdea1505dabd6164e57bcf8eb2602e9bd3046 --- /dev/null +++ b/uncategorized/devops/chaos-engineering-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "chaos-engineering-workflow", + "workflow_id": "chaos-engineering", + "title": "Chaos Engineering Workflow", + "kind": "workflow", + "source_domain": "devops", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "chaos-engineering", + "fault-injection", + "resilience-testing", + "game-day", + "blast-radius", + "steady-state" + ], + "description": "Chaos engineering workflow with hypothesis definition, steady-state monitoring, controlled fault injection, blast radius limitation, and resilience validation.", + "source_path": "devops/chaos-engineering", + "repo_path": "uncategorized/devops/chaos-engineering-workflow" +} diff --git a/uncategorized/devops/chaos-engineering-workflow/workflow.fz b/uncategorized/devops/chaos-engineering-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3ec0f8ac7009327ddb1f038048d25fe160fdb435 --- /dev/null +++ b/uncategorized/devops/chaos-engineering-workflow/workflow.fz @@ -0,0 +1,49 @@ +SRE { # SRE Team + n1: circle label:"Start" + n2: rectangle label:"Define experiment hypothesis" + n3: rectangle label:"Select blast radius" + n4: rectangle label:"Review experiment results" + n5: rectangle label:"Document learnings" + n6: circle label:"End" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) + n3.handle(bottom) -> ChaosMonkey.n7.handle(top) [label="Configure"] + n4.handle(right) -> n5.handle(left) + n5.handle(right) -> n6.handle(left) +} +ChaosMonkey { # Chaos Monkey + n7: rectangle label:"Schedule experiment window" + n8: diamond label:"Steady state verified?" + n9: rectangle label:"Inject failure" + n10: rectangle label:"Abort experiment" + n11: diamond label:"Failure type?" + n12: rectangle label:"Kill random instance" + n13: rectangle label:"Inject network latency" + n14: rectangle label:"Exhaust CPU resources" + n7.handle(right) -> n8.handle(left) + n8.handle(right) -> n9.handle(left) [label="Yes"] + n8.handle(bottom) -> n10.handle(top) [label="No"] + n9.handle(right) -> n11.handle(left) + n10.handle(top) -> SRE.n4.handle(bottom) [label="Aborted"] + n11.handle(right) -> n12.handle(left) [label="Instance"] + n11.handle(bottom) -> n13.handle(top) [label="Network"] + n11.handle(left) -> n14.handle(top) [label="Resource"] + n12.handle(bottom) -> Observability.n15.handle(top) [label="Monitor"] + n13.handle(bottom) -> Observability.n15.handle(top) [label="Monitor"] + n14.handle(bottom) -> Observability.n15.handle(top) [label="Monitor"] +} +Observability { # Observability + n15: rectangle label:"Monitor system metrics" + n16: rectangle label:"Track error rates" + n17: diamond label:"System recovered?" + n18: rectangle label:"Record recovery time" + n19: rectangle label:"Trigger rollback" + n20: rectangle label:"Generate experiment report" + n15.handle(right) -> n16.handle(left) + n16.handle(right) -> n17.handle(left) + n17.handle(right) -> n18.handle(left) [label="Yes"] + n17.handle(bottom) -> n19.handle(top) [label="No"] + n18.handle(right) -> n20.handle(left) + n19.handle(right) -> n20.handle(top) + n20.handle(top) -> SRE.n4.handle(bottom) [label="Results ready"] +} \ No newline at end of file diff --git a/uncategorized/finance/bank-reconciliation-workflow/README.md b/uncategorized/finance/bank-reconciliation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..efb5efacacdb45a07a19039a9ad1c0ef1fbbaea7 --- /dev/null +++ b/uncategorized/finance/bank-reconciliation-workflow/README.md @@ -0,0 +1,19 @@ +# Bank Reconciliation Workflow + +Bank reconciliation workflow with automated transaction matching, variance reporting, discrepancy research, and journal entry creation for timing differences and bank errors. + +**Template ID:** `bank-reconciliation-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 18 +**Lanes:** 3 +**Tags:** [bank-reconciliation, gl-matching, variance-analysis, journal-entries, auto-matching, discrepancy-resolution] +**Source path:** `finance/bank-reconciliation` +**Repo path:** `uncategorized/finance/bank-reconciliation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/bank-reconciliation-workflow/metadata.json b/uncategorized/finance/bank-reconciliation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8c4e61d3903f400e45fed1e3f8263bda73495bf9 --- /dev/null +++ b/uncategorized/finance/bank-reconciliation-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "bank-reconciliation-workflow", + "workflow_id": "bank-reconciliation", + "title": "Bank Reconciliation Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 18, + "num_lanes": 3, + "tags": [ + "bank-reconciliation", + "gl-matching", + "variance-analysis", + "journal-entries", + "auto-matching", + "discrepancy-resolution" + ], + "description": "Bank reconciliation workflow with automated transaction matching, variance reporting, discrepancy research, and journal entry creation for timing differences and bank errors.", + "source_path": "finance/bank-reconciliation", + "repo_path": "uncategorized/finance/bank-reconciliation-workflow" +} diff --git a/uncategorized/finance/bank-reconciliation-workflow/workflow.fz b/uncategorized/finance/bank-reconciliation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..74b2330b67c164558a77d5c677c25bd05290d7b2 --- /dev/null +++ b/uncategorized/finance/bank-reconciliation-workflow/workflow.fz @@ -0,0 +1,44 @@ +Accountant { # Accountant +n1: circle label:"Start" +n2: rectangle label:"Import bank statement" +n3: rectangle label:"Review reconciliation report" +n4: rectangle label:"Approve reconciliation" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> ReconciliationEngine.n6.handle(top) [label="Process"] +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) +} +ReconciliationEngine { # Reconciliation Engine +n6: rectangle label:"Parse bank transactions" +n7: rectangle label:"Match with GL entries" +n8: diamond label:"Auto-match rate?" +n9: rectangle label:"Flag unmatched items" +n10: rectangle label:"Apply matching rules" +n11: rectangle label:"Generate variance report" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n11.handle(left) [label="> 95%"] +n8.handle(bottom) -> n9.handle(top) [label="< 95%"] +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(top) +n11.handle(bottom) -> ManualReview.n12.handle(top) [label="Review"] +} +ManualReview { # Manual Review +n12: rectangle label:"Display unmatched items" +n13: rectangle label:"Research discrepancies" +n14: diamond label:"Discrepancy type?" +n15: rectangle label:"Create journal entry" +n16: rectangle label:"Flag for investigation" +n17: rectangle label:"Mark as bank error" +n18: rectangle label:"Update reconciliation status" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Timing"] +n14.handle(bottom) -> n16.handle(top) [label="Unknown"] +n14.handle(left) -> n17.handle(top) [label="Bank error"] +n15.handle(right) -> n18.handle(left) +n16.handle(right) -> n18.handle(top) +n17.handle(right) -> n18.handle(top) +n18.handle(top) -> Accountant.n3.handle(bottom) [label="Complete"] +} diff --git a/uncategorized/finance/cash-flow-forecast-workflow/README.md b/uncategorized/finance/cash-flow-forecast-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6b09b1c0dcae57f6dae6a0a513cf1c3e3d8d1a7a --- /dev/null +++ b/uncategorized/finance/cash-flow-forecast-workflow/README.md @@ -0,0 +1,19 @@ +# Cash Flow Forecast Workflow + +Cash flow forecasting workflow with AR/AP projections, working capital analysis, liquidity gap identification, and short-term financing recommendations. + +**Template ID:** `cash-flow-forecast-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [cash-flow-forecast, liquidity-planning, working-capital, ar-collections, ap-disbursements, treasury] +**Source path:** `finance/cash-flow-forecast` +**Repo path:** `uncategorized/finance/cash-flow-forecast-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/cash-flow-forecast-workflow/metadata.json b/uncategorized/finance/cash-flow-forecast-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d5656bb895701ba649ea0e0477717c7df2df52d5 --- /dev/null +++ b/uncategorized/finance/cash-flow-forecast-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "cash-flow-forecast-workflow", + "workflow_id": "cash-flow-forecast", + "title": "Cash Flow Forecast Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "cash-flow-forecast", + "liquidity-planning", + "working-capital", + "ar-collections", + "ap-disbursements", + "treasury" + ], + "description": "Cash flow forecasting workflow with AR/AP projections, working capital analysis, liquidity gap identification, and short-term financing recommendations.", + "source_path": "finance/cash-flow-forecast", + "repo_path": "uncategorized/finance/cash-flow-forecast-workflow" +} diff --git a/uncategorized/finance/cash-flow-forecast-workflow/workflow.fz b/uncategorized/finance/cash-flow-forecast-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..fad2e98750482f52b2f13c5c2cacb032320dd747 --- /dev/null +++ b/uncategorized/finance/cash-flow-forecast-workflow/workflow.fz @@ -0,0 +1,19 @@ +employee { # Employee + n1: circle label:"Start Cash Flow Forecast" + n2: diamond label:"Receive Cash Flow Forecast request" + n3: rectangle label:"Review Cash Flow Forecast details" + n5: rectangle label:"Update records for Cash Flow Forecast" + n7: circle label:"End Cash Flow Forecast" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> manager.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> manager.n6.handle(top) +} + +manager { # Manager + n4: rectangle label:"Make Cash Flow Forecast decision" + n6: rectangle label:"Continue Cash Flow Forecast process" + n4.handle(right) -> employee.n5.handle(top) + n6.handle(right) -> employee.n7.handle(bottom) +} diff --git a/uncategorized/finance/cost-center-workflow/README.md b/uncategorized/finance/cost-center-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..04c967b9812795a3d25a0e4f5497f8fb9eb111d9 --- /dev/null +++ b/uncategorized/finance/cost-center-workflow/README.md @@ -0,0 +1,19 @@ +# Cost Center Workflow + +This workflow models managing cost center budgets. + +**Template ID:** `cost-center-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [cost, center, finance, decision] +**Source path:** `finance/cost-center` +**Repo path:** `uncategorized/finance/cost-center-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/cost-center-workflow/metadata.json b/uncategorized/finance/cost-center-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..97faa5ea890122235297d7cb17573534140c92c4 --- /dev/null +++ b/uncategorized/finance/cost-center-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "cost-center-workflow", + "workflow_id": "cost-center", + "title": "Cost Center Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "cost", + "center", + "finance", + "decision" + ], + "description": "This workflow models managing cost center budgets.", + "source_path": "finance/cost-center", + "repo_path": "uncategorized/finance/cost-center-workflow" +} diff --git a/uncategorized/finance/cost-center-workflow/workflow.fz b/uncategorized/finance/cost-center-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..835e3b59af0b981a773c0a55b3a015fd57398a5d --- /dev/null +++ b/uncategorized/finance/cost-center-workflow/workflow.fz @@ -0,0 +1,19 @@ +employee { # Employee + n1: circle label:"Start Cost Center" + n2: diamond label:"Receive Cost Center request" + n3: rectangle label:"Review Cost Center details" + n5: rectangle label:"Update records for Cost Center" + n7: circle label:"End Cost Center" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> manager.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> manager.n6.handle(top) +} + +manager { # Manager + n4: rectangle label:"Make Cost Center decision" + n6: rectangle label:"Continue Cost Center process" + n6.handle(right) -> employee.n7.handle(bottom) + n4.handle(right) -> employee.n5.handle(top) +} diff --git a/uncategorized/finance/credit-control-workflow/README.md b/uncategorized/finance/credit-control-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b02fa280dc3673fd29d592375fd3977ef00d4445 --- /dev/null +++ b/uncategorized/finance/credit-control-workflow/README.md @@ -0,0 +1,19 @@ +# Credit Control Workflow + +Customer credit control workflow with credit limit assessment, credit scoring, order hold management, collections escalation, and payment plan negotiation. + +**Template ID:** `credit-control-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [credit-control, credit-limit, customer-credit, credit-scoring, collections, accounts-receivable] +**Source path:** `finance/credit-control` +**Repo path:** `uncategorized/finance/credit-control-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/credit-control-workflow/metadata.json b/uncategorized/finance/credit-control-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d4145140db17b26a5ca595565d839ffced909f0b --- /dev/null +++ b/uncategorized/finance/credit-control-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "credit-control-workflow", + "workflow_id": "credit-control", + "title": "Credit Control Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "credit-control", + "credit-limit", + "customer-credit", + "credit-scoring", + "collections", + "accounts-receivable" + ], + "description": "Customer credit control workflow with credit limit assessment, credit scoring, order hold management, collections escalation, and payment plan negotiation.", + "source_path": "finance/credit-control", + "repo_path": "uncategorized/finance/credit-control-workflow" +} diff --git a/uncategorized/finance/credit-control-workflow/workflow.fz b/uncategorized/finance/credit-control-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..4a3cddfc1b0173168487f331e2ae886f932890dd --- /dev/null +++ b/uncategorized/finance/credit-control-workflow/workflow.fz @@ -0,0 +1,34 @@ +employee { # Employee + n1: circle label:"Start Credit Control" + n4: rectangle label:"Make Credit Control decision" + n7: rectangle label:"Continue Credit Control process" + n10: circle label:"End Credit Control" + n1.handle(bottom) -> manager.n2.handle(top) + n1.handle(bottom) -> finance_app.n3.handle(top) + n1.handle(right) -> n4.handle(left) + n1.handle(bottom) -> manager.n5.handle(top) + n1.handle(bottom) -> finance_app.n6.handle(top) + n1.handle(right) -> n7.handle(left) + n1.handle(bottom) -> manager.n8.handle(top) + n1.handle(bottom) -> finance_app.n9.handle(top) + n4.handle(right) -> n10.handle(left) + n7.handle(right) -> n10.handle(left) +} + +manager { # Manager + n2: rectangle label:"Receive Credit Control request" + n5: rectangle label:"Update records for Credit Control" + n8: rectangle label:"Continue Credit Control process" + n2.handle(right) -> employee.n10.handle(bottom) + n8.handle(right) -> employee.n10.handle(bottom) + n5.handle(right) -> employee.n10.handle(bottom) +} + +finance_app { # Finance_App + n3: rectangle label:"Review Credit Control details" + n6: diamond label:"Continue Credit Control process" + n9: rectangle label:"Continue Credit Control process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n10.handle(bottom) + n3.handle(right) -> employee.n10.handle(bottom) +} diff --git a/uncategorized/finance/expense-allocation-workflow/README.md b/uncategorized/finance/expense-allocation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4f8f0f8c35700c4fad0cf7628ee22fb7d136c2cd --- /dev/null +++ b/uncategorized/finance/expense-allocation-workflow/README.md @@ -0,0 +1,19 @@ +# Expense Allocation Workflow + +This workflow models allocating costs to departments. + +**Template ID:** `expense-allocation-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [expense, allocation, finance] +**Source path:** `finance/expense-allocation` +**Repo path:** `uncategorized/finance/expense-allocation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/expense-allocation-workflow/metadata.json b/uncategorized/finance/expense-allocation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..04e0fda9bfed40b85041b0b38b74c0f6f80979b5 --- /dev/null +++ b/uncategorized/finance/expense-allocation-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "expense-allocation-workflow", + "workflow_id": "expense-allocation", + "title": "Expense Allocation Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "expense", + "allocation", + "finance" + ], + "description": "This workflow models allocating costs to departments.", + "source_path": "finance/expense-allocation", + "repo_path": "uncategorized/finance/expense-allocation-workflow" +} diff --git a/uncategorized/finance/expense-allocation-workflow/workflow.fz b/uncategorized/finance/expense-allocation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c1ad471cb1e061764c38609f6d6f40357eec8e88 --- /dev/null +++ b/uncategorized/finance/expense-allocation-workflow/workflow.fz @@ -0,0 +1,28 @@ +employee { # Employee + n1: circle label:"Start Expense Allocation" + n4: rectangle label:"Make Expense Allocation decision" + n7: rectangle label:"Continue Expense Allocation process" + n10: circle label:"End Expense Allocation" + n1.handle(bottom) -> manager.n2.handle(top) [label="Success"] + n4.handle(bottom) -> manager.n5.handle(top) [label="Valid"] + n7.handle(bottom) -> manager.n8.handle(top) [label="Next"] +} + +manager { # Manager + n2: rectangle label:"Receive Expense Allocation request" + n5: rectangle label:"Update records for Expense Allocation" + n8: rectangle label:"Continue Expense Allocation process" + n2.handle(bottom) -> finance_app.n3.handle(top) + n5.handle(bottom) -> finance_app.n6.handle(top) + n8.handle(bottom) -> finance_app.n9.handle(top) +} + +finance_app { # Finance_App + n3: rectangle label:"Review Expense Allocation details" + n6: rectangle label:"Continue Expense Allocation process" + n9: diamond label:"Continue Expense Allocation process" + n9.handle(right) -> employee.n10.handle(bottom) + n9.handle(left) -> manager.n8.handle(left) [label="Retry/Rejected"] + n6.handle(right) -> employee.n7.handle(left) + n3.handle(right) -> employee.n4.handle(left) +} diff --git a/uncategorized/finance/fixed-assets-workflow/README.md b/uncategorized/finance/fixed-assets-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0539a4cd7b217d0b5aca82a4bc87459db83fb546 --- /dev/null +++ b/uncategorized/finance/fixed-assets-workflow/README.md @@ -0,0 +1,19 @@ +# Fixed Assets Workflow + +Fixed asset management workflow with asset capitalization, depreciation scheduling, physical inventory verification, and asset disposal/retirement processing. + +**Template ID:** `fixed-assets-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [fixed-assets, asset-tracking, depreciation, capitalization, asset-disposal, physical-inventory] +**Source path:** `finance/fixed-assets` +**Repo path:** `uncategorized/finance/fixed-assets-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/fixed-assets-workflow/metadata.json b/uncategorized/finance/fixed-assets-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f3623ec7dba30259afa051fedc1b768a03f3536a --- /dev/null +++ b/uncategorized/finance/fixed-assets-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "fixed-assets-workflow", + "workflow_id": "fixed-assets", + "title": "Fixed Assets Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "fixed-assets", + "asset-tracking", + "depreciation", + "capitalization", + "asset-disposal", + "physical-inventory" + ], + "description": "Fixed asset management workflow with asset capitalization, depreciation scheduling, physical inventory verification, and asset disposal/retirement processing.", + "source_path": "finance/fixed-assets", + "repo_path": "uncategorized/finance/fixed-assets-workflow" +} diff --git a/uncategorized/finance/fixed-assets-workflow/workflow.fz b/uncategorized/finance/fixed-assets-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..19cccbb05de4bdece1c1728e1d016a672cc9375b --- /dev/null +++ b/uncategorized/finance/fixed-assets-workflow/workflow.fz @@ -0,0 +1,18 @@ +employee { # Employee + n1: circle label:"Start Fixed Assets" + n3: rectangle label:"Review Fixed Assets details" + n5: rectangle label:"Update records for Fixed Assets" + n7: circle label:"End Fixed Assets" + n1.handle(bottom) -> manager.n2.handle(top) + n3.handle(bottom) -> manager.n4.handle(top) [label="Processed"] + n5.handle(bottom) -> manager.n6.handle(top) +} + +manager { # Manager + n2: rectangle label:"Receive Fixed Assets request" + n4: rectangle label:"Make Fixed Assets decision" + n6: rectangle label:"Continue Fixed Assets process" + n6.handle(right) -> employee.n7.handle(bottom) [label="Success"] + n4.handle(right) -> employee.n5.handle(left) + n2.handle(right) -> employee.n3.handle(left) +} diff --git a/uncategorized/finance/monthly-close-workflow/README.md b/uncategorized/finance/monthly-close-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..018448baee6c729e2bb07863b1b3b5437846791a --- /dev/null +++ b/uncategorized/finance/monthly-close-workflow/README.md @@ -0,0 +1,19 @@ +# Monthly Close Workflow + +Corporate month-end financial close process including transaction posting, bank reconciliation, accruals, depreciation, trial balance validation, and financial statement generation. + +**Template ID:** `monthly-close-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 22 +**Lanes:** 4 +**Tags:** [monthly-close, financial-reporting, accounting, reconciliation, trial-balance, period-close] +**Source path:** `finance/monthly-close` +**Repo path:** `uncategorized/finance/monthly-close-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/monthly-close-workflow/metadata.json b/uncategorized/finance/monthly-close-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bde707e77fc86f5abe30f74dbea4441b7e89be2b --- /dev/null +++ b/uncategorized/finance/monthly-close-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "monthly-close-workflow", + "workflow_id": "monthly-close", + "title": "Monthly Close Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 22, + "num_lanes": 4, + "tags": [ + "monthly-close", + "financial-reporting", + "accounting", + "reconciliation", + "trial-balance", + "period-close" + ], + "description": "Corporate month-end financial close process including transaction posting, bank reconciliation, accruals, depreciation, trial balance validation, and financial statement generation.", + "source_path": "finance/monthly-close", + "repo_path": "uncategorized/finance/monthly-close-workflow" +} diff --git a/uncategorized/finance/monthly-close-workflow/workflow.fz b/uncategorized/finance/monthly-close-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..90e64167bc18bed95d97f8b4f357326576fa9b00 --- /dev/null +++ b/uncategorized/finance/monthly-close-workflow/workflow.fz @@ -0,0 +1,53 @@ +Controller { # Controller +n1: circle label:"Start" +n2: rectangle label:"Initiate month-end close" +n3: rectangle label:"Review close checklist" +n4: rectangle label:"Approve financial statements" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Accounting.n6.handle(top) [label="Begin close"] +n3.handle(bottom) -> Reporting.n18.handle(top) [label="Generate reports"] +n4.handle(right) -> n5.handle(left) +} +Accounting { # Accounting Team +n6: rectangle label:"Post pending transactions" +n7: rectangle label:"Reconcile bank accounts" +n8: diamond label:"Reconciliation balanced?" +n9: rectangle label:"Record accruals" +n10: rectangle label:"Investigate variances" +n11: rectangle label:"Post depreciation" +n12: rectangle label:"Review intercompany" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(top) -> n7.handle(bottom) [label="Recheck"] +n11.handle(right) -> n12.handle(left) +n12.handle(bottom) -> Validation.n13.handle(top) [label="Validate"] +} +Validation { # Validation +n13: rectangle label:"Run trial balance" +n14: diamond label:"Debits equal credits?" +n15: rectangle label:"Review account balances" +n16: rectangle label:"Identify discrepancies" +n17: rectangle label:"Lock accounting period" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="Yes"] +n14.handle(bottom) -> n16.handle(top) [label="No"] +n15.handle(right) -> n17.handle(left) +n16.handle(top) -> Accounting.n6.handle(bottom) [label="Correct"] +n17.handle(top) -> Controller.n3.handle(bottom) [label="Period closed"] +} +Reporting { # Financial Reporting +n18: rectangle label:"Generate income statement" +n19: rectangle label:"Generate balance sheet" +n20: rectangle label:"Generate cash flow statement" +n21: rectangle label:"Prepare variance analysis" +n22: rectangle label:"Package for leadership" +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) +n21.handle(right) -> n22.handle(left) +n22.handle(top) -> Controller.n4.handle(bottom) [label="Ready for review"] +} diff --git a/uncategorized/finance/procurement-card-workflow/README.md b/uncategorized/finance/procurement-card-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9409ff9c4541c5fb586fb8e8b2f365fc99eaabbc --- /dev/null +++ b/uncategorized/finance/procurement-card-workflow/README.md @@ -0,0 +1,19 @@ +# Procurement Card Workflow + +This workflow models managing company credit cards. + +**Template ID:** `procurement-card-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [procurement, card, finance] +**Source path:** `finance/procurement-card` +**Repo path:** `uncategorized/finance/procurement-card-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/procurement-card-workflow/metadata.json b/uncategorized/finance/procurement-card-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..a546b6d54455a828b1d59ba54286483a27732e5f --- /dev/null +++ b/uncategorized/finance/procurement-card-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "procurement-card-workflow", + "workflow_id": "procurement-card", + "title": "Procurement Card Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "procurement", + "card", + "finance" + ], + "description": "This workflow models managing company credit cards.", + "source_path": "finance/procurement-card", + "repo_path": "uncategorized/finance/procurement-card-workflow" +} diff --git a/uncategorized/finance/procurement-card-workflow/workflow.fz b/uncategorized/finance/procurement-card-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ded130bff7c4a1e985d6c8a197a11d2142608edd --- /dev/null +++ b/uncategorized/finance/procurement-card-workflow/workflow.fz @@ -0,0 +1,28 @@ +employee { # Employee + n1: circle label:"Start Procurement Card" + n4: diamond label:"Make Procurement Card decision" + n7: rectangle label:"Continue Procurement Card process" + n10: circle label:"End Procurement Card" + n1.handle(bottom) -> manager.n2.handle(top) + n4.handle(bottom) -> manager.n5.handle(top) + n7.handle(bottom) -> manager.n8.handle(top) + n4.handle(right) -> finance_app.n3.handle(bottom) [label="Retry/Rejected"] +} + +manager { # Manager + n2: rectangle label:"Receive Procurement Card request" + n5: rectangle label:"Update records for Procurement Card" + n8: rectangle label:"Continue Procurement Card process" + n2.handle(bottom) -> finance_app.n3.handle(top) + n5.handle(bottom) -> finance_app.n6.handle(top) + n8.handle(bottom) -> finance_app.n9.handle(top) +} + +finance_app { # Finance_App + n3: rectangle label:"Review Procurement Card details" + n6: rectangle label:"Continue Procurement Card process" + n9: rectangle label:"Continue Procurement Card process" + n9.handle(right) -> employee.n10.handle(bottom) [label="Valid"] + n6.handle(right) -> employee.n7.handle(left) [label="Success"] + n3.handle(right) -> employee.n4.handle(left) [label="Processed"] +} diff --git a/uncategorized/finance/treasury-management-workflow/README.md b/uncategorized/finance/treasury-management-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..343278be4a77bd354165edb8f4090cd68718a138 --- /dev/null +++ b/uncategorized/finance/treasury-management-workflow/README.md @@ -0,0 +1,19 @@ +# Treasury Management Workflow + +Corporate treasury management workflow with cash pooling, FX exposure hedging, short-term investment decisions, and bank relationship management. + +**Template ID:** `treasury-management-workflow` +**Kind:** workflow +**Source domain:** finance +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [treasury-management, cash-pooling, fx-hedging, investment-portfolio, bank-relationships, liquidity] +**Source path:** `finance/treasury-management` +**Repo path:** `uncategorized/finance/treasury-management-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/finance/treasury-management-workflow/metadata.json b/uncategorized/finance/treasury-management-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..aafb27e2aed8f74c501035bb4116d6bc0183fd09 --- /dev/null +++ b/uncategorized/finance/treasury-management-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "treasury-management-workflow", + "workflow_id": "treasury-management", + "title": "Treasury Management Workflow", + "kind": "workflow", + "source_domain": "finance", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "treasury-management", + "cash-pooling", + "fx-hedging", + "investment-portfolio", + "bank-relationships", + "liquidity" + ], + "description": "Corporate treasury management workflow with cash pooling, FX exposure hedging, short-term investment decisions, and bank relationship management.", + "source_path": "finance/treasury-management", + "repo_path": "uncategorized/finance/treasury-management-workflow" +} diff --git a/uncategorized/finance/treasury-management-workflow/workflow.fz b/uncategorized/finance/treasury-management-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..f304c8d5b8ac1bb459641dc5e84554ab2a45ea12 --- /dev/null +++ b/uncategorized/finance/treasury-management-workflow/workflow.fz @@ -0,0 +1,18 @@ +employee { # Employee + n1: circle label:"Start Treasury Management" + n3: rectangle label:"Review Treasury Management details" + n5: rectangle label:"Update records for Treasury Management" + n7: circle label:"End Treasury Management" + n1.handle(bottom) -> manager.n2.handle(top) + n3.handle(bottom) -> manager.n4.handle(top) [label="Processed"] + n5.handle(bottom) -> manager.n6.handle(top) +} + +manager { # Manager + n2: rectangle label:"Receive Treasury Management request" + n4: rectangle label:"Make Treasury Management decision" + n6: rectangle label:"Continue Treasury Management process" + n6.handle(right) -> employee.n7.handle(bottom) [label="Success"] + n4.handle(right) -> employee.n5.handle(left) + n2.handle(right) -> employee.n3.handle(left) +} diff --git a/uncategorized/hr/background-check-workflow/README.md b/uncategorized/hr/background-check-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5fc9c3ec930d45e58395ec27d2c2cd200e32d2f1 --- /dev/null +++ b/uncategorized/hr/background-check-workflow/README.md @@ -0,0 +1,19 @@ +# Background Check Workflow + +Pre-employment background check workflow with criminal history search, employment verification, education verification, and drug screening coordination. + +**Template ID:** `background-check-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [background-check, pre-employment, criminal-history, employment-verification, education-verification, drug-screening] +**Source path:** `hr/background-check` +**Repo path:** `uncategorized/hr/background-check-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/background-check-workflow/metadata.json b/uncategorized/hr/background-check-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c4bc9b24199b8ec937d1dc373dec55eda28ed3f3 --- /dev/null +++ b/uncategorized/hr/background-check-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "background-check-workflow", + "workflow_id": "background-check", + "title": "Background Check Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "background-check", + "pre-employment", + "criminal-history", + "employment-verification", + "education-verification", + "drug-screening" + ], + "description": "Pre-employment background check workflow with criminal history search, employment verification, education verification, and drug screening coordination.", + "source_path": "hr/background-check", + "repo_path": "uncategorized/hr/background-check-workflow" +} diff --git a/uncategorized/hr/background-check-workflow/workflow.fz b/uncategorized/hr/background-check-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..fc0f8ee5444ba235b55ec67bc724c34e8336aa0e --- /dev/null +++ b/uncategorized/hr/background-check-workflow/workflow.fz @@ -0,0 +1,19 @@ +employee { # Employee + n1: circle label:"Start Background Check" + n3: rectangle label:"Review Background Check details" + n5: rectangle label:"Update records for Background Check" + n7: circle label:"End Background Check" + n1.handle(bottom) -> manager.n2.handle(top) + n3.handle(bottom) -> manager.n4.handle(top) + n5.handle(bottom) -> manager.n6.handle(top) [label="Done"] +} + +manager { # Manager + n2: rectangle label:"Receive Background Check request" + n4: diamond label:"Make Background Check decision" + n6: rectangle label:"Continue Background Check process" + n6.handle(right) -> employee.n7.handle(bottom) + n4.handle(right) -> employee.n5.handle(left) + n4.handle(left) -> employee.n3.handle(left) [label="Retry/Rejected"] + n2.handle(right) -> employee.n3.handle(top) [label="Next"] +} diff --git a/uncategorized/hr/bonus-allocation-workflow/README.md b/uncategorized/hr/bonus-allocation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..14716049feaaeee17948dd253c42ef5cdfc1c706 --- /dev/null +++ b/uncategorized/hr/bonus-allocation-workflow/README.md @@ -0,0 +1,19 @@ +# Bonus Allocation Workflow + +Annual bonus allocation workflow with budget pool distribution, performance-based calculation, manager calibration, executive approval, and payroll processing. + +**Template ID:** `bonus-allocation-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [bonus-allocation, annual-bonus, performance-bonus, budget-pool, calibration, payout] +**Source path:** `hr/bonus-allocation` +**Repo path:** `uncategorized/hr/bonus-allocation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/bonus-allocation-workflow/metadata.json b/uncategorized/hr/bonus-allocation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..678f204c925123bf09bcc95a4c1b62672f21aa24 --- /dev/null +++ b/uncategorized/hr/bonus-allocation-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "bonus-allocation-workflow", + "workflow_id": "bonus-allocation", + "title": "Bonus Allocation Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "bonus-allocation", + "annual-bonus", + "performance-bonus", + "budget-pool", + "calibration", + "payout" + ], + "description": "Annual bonus allocation workflow with budget pool distribution, performance-based calculation, manager calibration, executive approval, and payroll processing.", + "source_path": "hr/bonus-allocation", + "repo_path": "uncategorized/hr/bonus-allocation-workflow" +} diff --git a/uncategorized/hr/bonus-allocation-workflow/workflow.fz b/uncategorized/hr/bonus-allocation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..bf8389e723b2cf5a21ee70e683c8857609753a2c --- /dev/null +++ b/uncategorized/hr/bonus-allocation-workflow/workflow.fz @@ -0,0 +1,20 @@ +employee { # Employee + n1: circle label:"Start Bonus Allocation" + n2: diamond label:"Receive Bonus Allocation request" + n3: rectangle label:"Review Bonus Allocation details" + n5: rectangle label:"Update records for Bonus Allocation" + n7: circle label:"End Bonus Allocation" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> manager.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> manager.n6.handle(top) + loop [retry until success] n2 n3 n5 n4 n6 +} + +manager { # Manager + n4: rectangle label:"Make Bonus Allocation decision" + n6: rectangle label:"Continue Bonus Allocation process" + n4.handle(right) -> employee.n5.handle(left) + n6.handle(right) -> employee.n7.handle(bottom) +} diff --git a/uncategorized/hr/candidate-rejection-workflow/README.md b/uncategorized/hr/candidate-rejection-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a2ae61243952916c40633faa9275f1730a34d61c --- /dev/null +++ b/uncategorized/hr/candidate-rejection-workflow/README.md @@ -0,0 +1,19 @@ +# Candidate Rejection Workflow + +Candidate rejection workflow with stage-appropriate messaging, personalized rejection letters, talent pool consideration, ATS status update, and candidate experience feedback. + +**Template ID:** `candidate-rejection-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [candidate-rejection, hiring-decision, rejection-letter, talent-pool, candidate-experience, ats-update] +**Source path:** `hr/candidate-rejection` +**Repo path:** `uncategorized/hr/candidate-rejection-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/candidate-rejection-workflow/metadata.json b/uncategorized/hr/candidate-rejection-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7a2e894d1eb2dbfae4cd0441a272e71e837a5d9f --- /dev/null +++ b/uncategorized/hr/candidate-rejection-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "candidate-rejection-workflow", + "workflow_id": "candidate-rejection", + "title": "Candidate Rejection Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "candidate-rejection", + "hiring-decision", + "rejection-letter", + "talent-pool", + "candidate-experience", + "ats-update" + ], + "description": "Candidate rejection workflow with stage-appropriate messaging, personalized rejection letters, talent pool consideration, ATS status update, and candidate experience feedback.", + "source_path": "hr/candidate-rejection", + "repo_path": "uncategorized/hr/candidate-rejection-workflow" +} diff --git a/uncategorized/hr/candidate-rejection-workflow/workflow.fz b/uncategorized/hr/candidate-rejection-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..5940b6b47040d77193036ada55d0c1a48a9a61f3 --- /dev/null +++ b/uncategorized/hr/candidate-rejection-workflow/workflow.fz @@ -0,0 +1,28 @@ +employee { # Employee + n1: circle label:"Start Candidate Rejection" + n2: diamond label:"Receive Candidate Rejection request" + n4: rectangle label:"Make Candidate Rejection decision" + n7: rectangle label:"Continue Candidate Rejection process" + n10: circle label:"End Candidate Rejection" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> hr_system.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> manager.n5.handle(top) + n7.handle(bottom) -> manager.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +manager { # Manager + n5: rectangle label:"Update records for Candidate Rejection" + n8: rectangle label:"Continue Candidate Rejection process" + n5.handle(bottom) -> hr_system.n6.handle(top) + n8.handle(bottom) -> hr_system.n9.handle(top) +} + +hr_system { # Hr_System + n3: rectangle label:"Review Candidate Rejection details" + n6: rectangle label:"Continue Candidate Rejection process" + n9: rectangle label:"Continue Candidate Rejection process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n7.handle(left) + n3.handle(right) -> manager.n5.handle(left) +} diff --git a/uncategorized/hr/diversity-initiative-workflow/README.md b/uncategorized/hr/diversity-initiative-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..52797c529481e41b9f0322c9a39f248a03da321a --- /dev/null +++ b/uncategorized/hr/diversity-initiative-workflow/README.md @@ -0,0 +1,19 @@ +# Diversity Initiative Workflow + +This workflow models promoting workplace diversity. + +**Template ID:** `diversity-initiative-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [diversity, initiative, hr] +**Source path:** `hr/diversity-initiative` +**Repo path:** `uncategorized/hr/diversity-initiative-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/diversity-initiative-workflow/metadata.json b/uncategorized/hr/diversity-initiative-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ee01ea16dbe8dd4f487c72bab504759222143487 --- /dev/null +++ b/uncategorized/hr/diversity-initiative-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "diversity-initiative-workflow", + "workflow_id": "diversity-initiative", + "title": "Diversity Initiative Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "diversity", + "initiative", + "hr" + ], + "description": "This workflow models promoting workplace diversity.", + "source_path": "hr/diversity-initiative", + "repo_path": "uncategorized/hr/diversity-initiative-workflow" +} diff --git a/uncategorized/hr/diversity-initiative-workflow/workflow.fz b/uncategorized/hr/diversity-initiative-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d84cff5fdfe799f31e4be6b92f299caba7c7468f --- /dev/null +++ b/uncategorized/hr/diversity-initiative-workflow/workflow.fz @@ -0,0 +1,28 @@ +employee { # Employee + n1: circle label:"Start Diversity Initiative" + n4: rectangle label:"Make Diversity Initiative decision" + n7: rectangle label:"Continue Diversity Initiative process" + n10: circle label:"End Diversity Initiative" + n1.handle(bottom) -> manager.n2.handle(top) + n4.handle(bottom) -> manager.n5.handle(top) + n7.handle(bottom) -> manager.n8.handle(top) +} + +manager { # Manager + n2: rectangle label:"Receive Diversity Initiative request" + n5: rectangle label:"Update records for Diversity Initiative" + n8: diamond label:"Continue Diversity Initiative process" + n2.handle(bottom) -> hr_system.n3.handle(top) + n5.handle(bottom) -> hr_system.n6.handle(top) + n8.handle(bottom) -> hr_system.n9.handle(top) + n8.handle(right) -> employee.n7.handle(right) [label="Retry/Rejected"] +} + +hr_system { # Hr_System + n3: rectangle label:"Review Diversity Initiative details" + n6: rectangle label:"Continue Diversity Initiative process" + n9: rectangle label:"Continue Diversity Initiative process" + n9.handle(right) -> employee.n10.handle(bottom) [label="Valid"] + n6.handle(right) -> employee.n7.handle(left) [label="Success"] + n3.handle(right) -> employee.n4.handle(left) [label="Processed"] +} diff --git a/uncategorized/hr/employee-engagement-workflow/README.md b/uncategorized/hr/employee-engagement-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..81ad2a455e01e44b5d78dc5be64d4d83981e1086 --- /dev/null +++ b/uncategorized/hr/employee-engagement-workflow/README.md @@ -0,0 +1,19 @@ +# Employee Engagement Workflow + +This workflow models measuring and improving engagement. + +**Template ID:** `employee-engagement-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [employee, engagement, hr, parallel] +**Source path:** `hr/employee-engagement` +**Repo path:** `uncategorized/hr/employee-engagement-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/employee-engagement-workflow/metadata.json b/uncategorized/hr/employee-engagement-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..191e17a9a75b9045cea0f7420b29bc6ba23b4095 --- /dev/null +++ b/uncategorized/hr/employee-engagement-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "employee-engagement-workflow", + "workflow_id": "employee-engagement", + "title": "Employee Engagement Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "employee", + "engagement", + "hr", + "parallel" + ], + "description": "This workflow models measuring and improving engagement.", + "source_path": "hr/employee-engagement", + "repo_path": "uncategorized/hr/employee-engagement-workflow" +} diff --git a/uncategorized/hr/employee-engagement-workflow/workflow.fz b/uncategorized/hr/employee-engagement-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..afa218e1b948377eff80906a1887fecb286b1b64 --- /dev/null +++ b/uncategorized/hr/employee-engagement-workflow/workflow.fz @@ -0,0 +1,22 @@ +employee { # Employee + n1: circle label:"Start Employee Engagement" + n3: rectangle label:"Review Employee Engagement details" + n5: rectangle label:"Update records for Employee Engagement" + n7: circle label:"End Employee Engagement" + n1.handle(bottom) -> manager.n2.handle(top) + n1.handle(right) -> n3.handle(left) + n1.handle(bottom) -> manager.n4.handle(top) + n1.handle(right) -> n5.handle(left) + n1.handle(bottom) -> manager.n6.handle(top) + n3.handle(right) -> n7.handle(left) + n5.handle(right) -> n7.handle(left) +} + +manager { # Manager + n2: rectangle label:"Receive Employee Engagement request" + n4: rectangle label:"Make Employee Engagement decision" + n6: rectangle label:"Continue Employee Engagement process" + n6.handle(right) -> employee.n7.handle(bottom) + n4.handle(right) -> employee.n7.handle(bottom) + n2.handle(right) -> employee.n7.handle(bottom) +} diff --git a/uncategorized/hr/internship-program-workflow/README.md b/uncategorized/hr/internship-program-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ef710c6fb250fd221fd7467121141a5122f1e7aa --- /dev/null +++ b/uncategorized/hr/internship-program-workflow/README.md @@ -0,0 +1,19 @@ +# Internship Program Workflow + +This workflow models managing an internship program. + +**Template ID:** `internship-program-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [internship, program, hr] +**Source path:** `hr/internship-program` +**Repo path:** `uncategorized/hr/internship-program-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/internship-program-workflow/metadata.json b/uncategorized/hr/internship-program-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6a1a45ef5b3c20a2a5821a3a46ade5bb16415c80 --- /dev/null +++ b/uncategorized/hr/internship-program-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "internship-program-workflow", + "workflow_id": "internship-program", + "title": "Internship Program Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "internship", + "program", + "hr" + ], + "description": "This workflow models managing an internship program.", + "source_path": "hr/internship-program", + "repo_path": "uncategorized/hr/internship-program-workflow" +} diff --git a/uncategorized/hr/internship-program-workflow/workflow.fz b/uncategorized/hr/internship-program-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..866a1ca6725f17e49babf9568f2624001844b9d5 --- /dev/null +++ b/uncategorized/hr/internship-program-workflow/workflow.fz @@ -0,0 +1,19 @@ +employee { # Employee + n1: circle label:"Start Internship Program" + n3: diamond label:"Review Internship Program details" + n5: rectangle label:"Update records for Internship Program" + n7: circle label:"End Internship Program" + n1.handle(bottom) -> manager.n2.handle(top) + n3.handle(bottom) -> manager.n4.handle(top) [label="Processed"] + n3.handle(right) -> manager.n2.handle(right) [label="Retry/Rejected"] + n5.handle(bottom) -> manager.n6.handle(top) +} + +manager { # Manager + n2: rectangle label:"Receive Internship Program request" + n4: rectangle label:"Make Internship Program decision" + n6: rectangle label:"Continue Internship Program process" + n6.handle(right) -> employee.n7.handle(bottom) [label="Success"] + n4.handle(right) -> employee.n5.handle(left) + n2.handle(bottom) -> employee.n3.handle(left) +} diff --git a/uncategorized/hr/interview-process-workflow/README.md b/uncategorized/hr/interview-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..87236aca0d13dc2f84a491f0882169599741bc61 --- /dev/null +++ b/uncategorized/hr/interview-process-workflow/README.md @@ -0,0 +1,19 @@ +# Interview Process Workflow + +Multi-stage interview process with resume screening, phone screen, technical interview, onsite panel, team consensus decision, and offer/rejection handling. + +**Template ID:** `interview-process-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 22 +**Lanes:** 3 +**Tags:** [interview-process, hiring, phone-screen, technical-interview, onsite-panel, talent-acquisition, offer-management] +**Source path:** `hr/interview-process` +**Repo path:** `uncategorized/hr/interview-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/interview-process-workflow/metadata.json b/uncategorized/hr/interview-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ec9ca3028dd40a5befc85d99358a6d7e9dcfac69 --- /dev/null +++ b/uncategorized/hr/interview-process-workflow/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "interview-process-workflow", + "workflow_id": "interview-process", + "title": "Interview Process Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 22, + "num_lanes": 3, + "tags": [ + "interview-process", + "hiring", + "phone-screen", + "technical-interview", + "onsite-panel", + "talent-acquisition", + "offer-management" + ], + "description": "Multi-stage interview process with resume screening, phone screen, technical interview, onsite panel, team consensus decision, and offer/rejection handling.", + "source_path": "hr/interview-process", + "repo_path": "uncategorized/hr/interview-process-workflow" +} diff --git a/uncategorized/hr/interview-process-workflow/workflow.fz b/uncategorized/hr/interview-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b55d51e4312c859128b1c59725e9d0eee2472ca9 --- /dev/null +++ b/uncategorized/hr/interview-process-workflow/workflow.fz @@ -0,0 +1,53 @@ +Candidate { # Candidate +n1: circle label:"Start" +n2: rectangle label:"Submit application" +n3: rectangle label:"Complete phone screen" +n4: rectangle label:"Attend technical interview" +n5: rectangle label:"Complete onsite interviews" +n6: rectangle label:"Receive offer or rejection" +n7: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Recruiter.n8.handle(top) [label="Apply"] +n3.handle(bottom) -> Recruiter.n12.handle(top) [label="Screen complete"] +n4.handle(bottom) -> HiringTeam.n16.handle(top) [label="Technical done"] +n5.handle(bottom) -> HiringTeam.n20.handle(top) [label="Onsite done"] +n6.handle(right) -> n7.handle(left) +} +Recruiter { # Recruiter +n8: rectangle label:"Review resume" +n9: diamond label:"Meets requirements?" +n10: rectangle label:"Schedule phone screen" +n11: rectangle label:"Send rejection email" +n12: diamond label:"Phone screen passed?" +n13: rectangle label:"Schedule technical round" +n14: rectangle label:"Add to talent pool" +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n11.handle(top) [label="No"] +n10.handle(top) -> Candidate.n3.handle(bottom) [label="Scheduled"] +n11.handle(top) -> Candidate.n6.handle(bottom) [label="Rejected"] +n12.handle(right) -> n13.handle(left) [label="Yes"] +n12.handle(bottom) -> n14.handle(top) [label="No"] +n13.handle(top) -> Candidate.n4.handle(bottom) [label="Scheduled"] +n14.handle(top) -> Candidate.n6.handle(bottom) [label="Not now"] +} +HiringTeam { # Hiring Team +n15: rectangle label:"Conduct technical interview" +n16: diamond label:"Technical skills sufficient?" +n17: rectangle label:"Schedule onsite panel" +n18: rectangle label:"Provide feedback" +n19: rectangle label:"Conduct onsite interviews" +n20: diamond label:"Team consensus?" +n21: rectangle label:"Extend offer" +n22: rectangle label:"Decline candidate" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> n18.handle(top) [label="No"] +n17.handle(top) -> Candidate.n5.handle(bottom) [label="Scheduled"] +n18.handle(top) -> Candidate.n6.handle(bottom) [label="Rejected"] +n19.handle(right) -> n20.handle(left) +n20.handle(right) -> n21.handle(left) [label="Hire"] +n20.handle(bottom) -> n22.handle(top) [label="No hire"] +n21.handle(top) -> Candidate.n6.handle(bottom) [label="Offer sent"] +n22.handle(top) -> Candidate.n6.handle(bottom) [label="Rejected"] +} diff --git a/uncategorized/hr/job-posting-workflow/README.md b/uncategorized/hr/job-posting-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..454ff44b66cd86f77cdc633674f7298ee1147b21 --- /dev/null +++ b/uncategorized/hr/job-posting-workflow/README.md @@ -0,0 +1,19 @@ +# Job Posting Workflow + +Job posting workflow with requisition approval, job description drafting, multi-channel posting (LinkedIn, Indeed, career sites), AI resume screening, and ATS candidate tracking. + +**Template ID:** `job-posting-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 3 +**Tags:** [job-posting, job-requisition, ats, linkedin, indeed, ai-screening, talent-acquisition] +**Source path:** `hr/job-posting` +**Repo path:** `uncategorized/hr/job-posting-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/job-posting-workflow/metadata.json b/uncategorized/hr/job-posting-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..1b3efe7e1c7457a039516c4e334123c58d637248 --- /dev/null +++ b/uncategorized/hr/job-posting-workflow/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "job-posting-workflow", + "workflow_id": "job-posting", + "title": "Job Posting Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 3, + "tags": [ + "job-posting", + "job-requisition", + "ats", + "linkedin", + "indeed", + "ai-screening", + "talent-acquisition" + ], + "description": "Job posting workflow with requisition approval, job description drafting, multi-channel posting (LinkedIn, Indeed, career sites), AI resume screening, and ATS candidate tracking.", + "source_path": "hr/job-posting", + "repo_path": "uncategorized/hr/job-posting-workflow" +} diff --git a/uncategorized/hr/job-posting-workflow/workflow.fz b/uncategorized/hr/job-posting-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b84a652e753ad712c87a737d801c324bbfba8f0c --- /dev/null +++ b/uncategorized/hr/job-posting-workflow/workflow.fz @@ -0,0 +1,45 @@ +HiringManager { # Hiring Manager +n1: circle label:"Start" +n2: rectangle label:"Submit job requisition" +n3: rectangle label:"Define requirements" +n4: rectangle label:"Review candidates" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> Recruiter.n6.handle(top) [label="Request"] +n3.handle(bottom) -> Recruiter.n11.handle(top) [label="Approved"] +n4.handle(right) -> n5.handle(left) +} +Recruiter { # Recruiter +n6: rectangle label:"Review requisition" +n7: diamond label:"Headcount approved?" +n8: rectangle label:"Draft job description" +n9: rectangle label:"Return for budget approval" +n10: rectangle label:"Select job boards" +n11: rectangle label:"Post to career sites" +n12: rectangle label:"Post to LinkedIn" +n13: rectangle label:"Post to Indeed" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(bottom) -> n9.handle(top) [label="No"] +n8.handle(right) -> n10.handle(left) +n9.handle(top) -> HiringManager.n3.handle(bottom) [label="Revise"] +n10.handle(bottom) -> n11.handle(top) +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) +n13.handle(bottom) -> ATS.n14.handle(top) [label="Track"] +} +ATS { # Applicant Tracking System +n14: rectangle label:"Collect applications" +n15: rectangle label:"Screen resumes with AI" +n16: diamond label:"Minimum qualifications?" +n17: rectangle label:"Add to candidate pool" +n18: rectangle label:"Send auto-rejection" +n19: rectangle label:"Notify recruiter" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> n18.handle(top) [label="No"] +n17.handle(right) -> n19.handle(left) +n18.handle(top) -> HiringManager.n5.handle(bottom) [label="Rejected"] +n19.handle(top) -> HiringManager.n4.handle(bottom) [label="Candidates ready"] +} diff --git a/uncategorized/hr/promotion-process-workflow/README.md b/uncategorized/hr/promotion-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fb927531151d12a33ceaba5f1d06d6e07578348e --- /dev/null +++ b/uncategorized/hr/promotion-process-workflow/README.md @@ -0,0 +1,19 @@ +# Promotion Process Workflow + +Employee promotion workflow with performance validation, job level assessment, compensation adjustment, title change, and announcement coordination. + +**Template ID:** `promotion-process-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [promotion-process, career-advancement, job-leveling, title-change, compensation-adjustment, succession-planning] +**Source path:** `hr/promotion-process` +**Repo path:** `uncategorized/hr/promotion-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/promotion-process-workflow/metadata.json b/uncategorized/hr/promotion-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..dec6502024fc1cb46290f38b5c69a23bfab66001 --- /dev/null +++ b/uncategorized/hr/promotion-process-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "promotion-process-workflow", + "workflow_id": "promotion-process", + "title": "Promotion Process Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "promotion-process", + "career-advancement", + "job-leveling", + "title-change", + "compensation-adjustment", + "succession-planning" + ], + "description": "Employee promotion workflow with performance validation, job level assessment, compensation adjustment, title change, and announcement coordination.", + "source_path": "hr/promotion-process", + "repo_path": "uncategorized/hr/promotion-process-workflow" +} diff --git a/uncategorized/hr/promotion-process-workflow/workflow.fz b/uncategorized/hr/promotion-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..c0e33e69fdf0fee9672f968f28075969ed533e9b --- /dev/null +++ b/uncategorized/hr/promotion-process-workflow/workflow.fz @@ -0,0 +1,19 @@ +employee { # Employee + n1: circle label:"Start Promotion Process" + n3: rectangle label:"Review Promotion Process details" + n5: rectangle label:"Update records for Promotion Process" + n7: circle label:"End Promotion Process" + n1.handle(bottom) -> manager.n2.handle(top) + n3.handle(bottom) -> manager.n4.handle(top) + n5.handle(bottom) -> manager.n6.handle(top) [label="Done"] +} + +manager { # Manager + n2: rectangle label:"Receive Promotion Process request" + n4: diamond label:"Make Promotion Process decision" + n6: rectangle label:"Continue Promotion Process process" + n6.handle(right) -> employee.n7.handle(bottom) + n4.handle(right) -> employee.n5.handle(left) + n4.handle(left) -> employee.n3.handle(left) [label="Retry/Rejected"] + n2.handle(right) -> employee.n3.handle(top) [label="Next"] +} diff --git a/uncategorized/hr/reference-check-workflow/README.md b/uncategorized/hr/reference-check-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..12e4e85499c12af65779ef5235cc4fc7cb53ed7a --- /dev/null +++ b/uncategorized/hr/reference-check-workflow/README.md @@ -0,0 +1,19 @@ +# Reference Check Workflow + +Professional reference check workflow with reference collection, outreach scheduling, structured interview questions, feedback documentation, and hiring recommendation. + +**Template ID:** `reference-check-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [reference-check, employment-verification, professional-references, hiring-decision, candidate-vetting, feedback-collection] +**Source path:** `hr/reference-check` +**Repo path:** `uncategorized/hr/reference-check-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/reference-check-workflow/metadata.json b/uncategorized/hr/reference-check-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f969a831c480998c7961cb23a38443c83a1799b1 --- /dev/null +++ b/uncategorized/hr/reference-check-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "reference-check-workflow", + "workflow_id": "reference-check", + "title": "Reference Check Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "reference-check", + "employment-verification", + "professional-references", + "hiring-decision", + "candidate-vetting", + "feedback-collection" + ], + "description": "Professional reference check workflow with reference collection, outreach scheduling, structured interview questions, feedback documentation, and hiring recommendation.", + "source_path": "hr/reference-check", + "repo_path": "uncategorized/hr/reference-check-workflow" +} diff --git a/uncategorized/hr/reference-check-workflow/workflow.fz b/uncategorized/hr/reference-check-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..a41e89eb6b98aec158e42585fc16b43ae1a6f5a5 --- /dev/null +++ b/uncategorized/hr/reference-check-workflow/workflow.fz @@ -0,0 +1,34 @@ +employee { # Employee + n1: circle label:"Start Reference Check" + n4: diamond label:"Make Reference Check decision" + n7: rectangle label:"Continue Reference Check process" + n10: circle label:"End Reference Check" + n1.handle(bottom) -> manager.n2.handle(top) + n1.handle(bottom) -> hr_system.n3.handle(top) + n1.handle(right) -> n4.handle(left) + n1.handle(bottom) -> manager.n5.handle(top) + n1.handle(bottom) -> hr_system.n6.handle(top) + n1.handle(right) -> n7.handle(left) + n1.handle(bottom) -> manager.n8.handle(top) + n1.handle(bottom) -> hr_system.n9.handle(top) + n4.handle(right) -> n10.handle(left) + n7.handle(right) -> n10.handle(left) +} + +manager { # Manager + n2: rectangle label:"Receive Reference Check request" + n5: rectangle label:"Update records for Reference Check" + n8: rectangle label:"Continue Reference Check process" + n2.handle(right) -> employee.n10.handle(bottom) + n5.handle(right) -> employee.n10.handle(bottom) + n8.handle(right) -> employee.n10.handle(bottom) +} + +hr_system { # Hr_System + n3: rectangle label:"Review Reference Check details" + n6: rectangle label:"Continue Reference Check process" + n9: rectangle label:"Continue Reference Check process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n10.handle(bottom) + n3.handle(right) -> employee.n10.handle(bottom) +} diff --git a/uncategorized/hr/relocation-assistance-workflow/README.md b/uncategorized/hr/relocation-assistance-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..114c37608d1d34759808cc865e27938c96ebbbe7 --- /dev/null +++ b/uncategorized/hr/relocation-assistance-workflow/README.md @@ -0,0 +1,19 @@ +# Relocation Assistance Workflow + +This workflow models helping employees relocate. + +**Template ID:** `relocation-assistance-workflow` +**Kind:** workflow +**Source domain:** hr +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [relocation, assistance, hr, decision] +**Source path:** `hr/relocation-assistance` +**Repo path:** `uncategorized/hr/relocation-assistance-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/hr/relocation-assistance-workflow/metadata.json b/uncategorized/hr/relocation-assistance-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e6e075bbed81ab0b3223a2c416e370de21d07575 --- /dev/null +++ b/uncategorized/hr/relocation-assistance-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "relocation-assistance-workflow", + "workflow_id": "relocation-assistance", + "title": "Relocation Assistance Workflow", + "kind": "workflow", + "source_domain": "hr", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "relocation", + "assistance", + "hr", + "decision" + ], + "description": "This workflow models helping employees relocate.", + "source_path": "hr/relocation-assistance", + "repo_path": "uncategorized/hr/relocation-assistance-workflow" +} diff --git a/uncategorized/hr/relocation-assistance-workflow/workflow.fz b/uncategorized/hr/relocation-assistance-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3a8ba32e9ae5a84250f91c37f0f39cdf9334d6b2 --- /dev/null +++ b/uncategorized/hr/relocation-assistance-workflow/workflow.fz @@ -0,0 +1,28 @@ +employee { # Employee + n1: circle label:"Start Relocation Assistance" + n2: diamond label:"Receive Relocation Assistance request" + n4: rectangle label:"Make Relocation Assistance decision" + n7: rectangle label:"Continue Relocation Assistance process" + n10: circle label:"End Relocation Assistance" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> hr_system.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> manager.n5.handle(top) + n7.handle(bottom) -> manager.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +manager { # Manager + n5: rectangle label:"Update records for Relocation Assistance" + n8: rectangle label:"Continue Relocation Assistance process" + n5.handle(bottom) -> hr_system.n6.handle(top) + n8.handle(bottom) -> hr_system.n9.handle(top) +} + +hr_system { # Hr_System + n3: rectangle label:"Review Relocation Assistance details" + n6: rectangle label:"Continue Relocation Assistance process" + n9: rectangle label:"Continue Relocation Assistance process" + n9.handle(right) -> employee.n10.handle(bottom) + n6.handle(right) -> employee.n7.handle(left) + n3.handle(right) -> manager.n5.handle(left) +} diff --git a/uncategorized/logistics/carrier-selection-workflow/README.md b/uncategorized/logistics/carrier-selection-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..accfdb6442268aa4eaa6b6e18728a657874ffcf9 --- /dev/null +++ b/uncategorized/logistics/carrier-selection-workflow/README.md @@ -0,0 +1,19 @@ +# Carrier Selection Workflow + +Carrier selection workflow with rate shopping, transit time comparison, service level matching, carrier performance scoring, and optimal carrier assignment. + +**Template ID:** `carrier-selection-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [carrier-selection, rate-shopping, transit-time, service-level, tms, freight-optimization] +**Source path:** `logistics/carrier-selection` +**Repo path:** `uncategorized/logistics/carrier-selection-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/carrier-selection-workflow/metadata.json b/uncategorized/logistics/carrier-selection-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..21c4ac971929677b78380c7ff738b5d3c1d0721b --- /dev/null +++ b/uncategorized/logistics/carrier-selection-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "carrier-selection-workflow", + "workflow_id": "carrier-selection", + "title": "Carrier Selection Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "carrier-selection", + "rate-shopping", + "transit-time", + "service-level", + "tms", + "freight-optimization" + ], + "description": "Carrier selection workflow with rate shopping, transit time comparison, service level matching, carrier performance scoring, and optimal carrier assignment.", + "source_path": "logistics/carrier-selection", + "repo_path": "uncategorized/logistics/carrier-selection-workflow" +} diff --git a/uncategorized/logistics/carrier-selection-workflow/workflow.fz b/uncategorized/logistics/carrier-selection-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..811574ba6b0f5a00bd6700c0c344f4459c6ef408 --- /dev/null +++ b/uncategorized/logistics/carrier-selection-workflow/workflow.fz @@ -0,0 +1,28 @@ +supplier { # Supplier + n1: circle label:"Start Carrier Selection" + n4: rectangle label:"Make Carrier Selection decision" + n7: rectangle label:"Continue Carrier Selection process" + n10: circle label:"End Carrier Selection" + n1.handle(bottom) -> warehouse.n2.handle(top) + n4.handle(bottom) -> warehouse.n5.handle(top) + n7.handle(bottom) -> warehouse.n8.handle(top) +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Carrier Selection request" + n5: rectangle label:"Update records for Carrier Selection" + n8: diamond label:"Continue Carrier Selection process" + n2.handle(bottom) -> iot_sensor.n3.handle(top) [label="Next"] + n5.handle(bottom) -> iot_sensor.n6.handle(top) [label="Done"] + n8.handle(bottom) -> iot_sensor.n9.handle(top) [label="Processed"] + n8.handle(right) -> supplier.n7.handle(right) [label="Retry/Rejected"] +} + +iot_sensor { # Iot_Sensor + n3: rectangle label:"Review Carrier Selection details" + n6: rectangle label:"Continue Carrier Selection process" + n9: rectangle label:"Continue Carrier Selection process" + n3.handle(right) -> supplier.n4.handle(left) + n6.handle(right) -> supplier.n7.handle(left) + n9.handle(right) -> supplier.n10.handle(bottom) +} diff --git a/uncategorized/logistics/container-loading-workflow/README.md b/uncategorized/logistics/container-loading-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..654df5f9c5658cdfac44bc694d4cffa48327c1bc --- /dev/null +++ b/uncategorized/logistics/container-loading-workflow/README.md @@ -0,0 +1,19 @@ +# Container Loading Workflow + +Container loading workflow with load plan optimization, weight distribution, cube utilization maximization, seal application, and bill of lading generation. + +**Template ID:** `container-loading-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [container-loading, load-planning, weight-distribution, cube-utilization, seal-verification, ocean-freight] +**Source path:** `logistics/container-loading` +**Repo path:** `uncategorized/logistics/container-loading-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/container-loading-workflow/metadata.json b/uncategorized/logistics/container-loading-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..adea4f445127e09035018cf47088043c5ab79d6a --- /dev/null +++ b/uncategorized/logistics/container-loading-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "container-loading-workflow", + "workflow_id": "container-loading", + "title": "Container Loading Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "container-loading", + "load-planning", + "weight-distribution", + "cube-utilization", + "seal-verification", + "ocean-freight" + ], + "description": "Container loading workflow with load plan optimization, weight distribution, cube utilization maximization, seal application, and bill of lading generation.", + "source_path": "logistics/container-loading", + "repo_path": "uncategorized/logistics/container-loading-workflow" +} diff --git a/uncategorized/logistics/container-loading-workflow/workflow.fz b/uncategorized/logistics/container-loading-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9d56be63cfd0be7bdae6fa8efa45d800b80ebeec --- /dev/null +++ b/uncategorized/logistics/container-loading-workflow/workflow.fz @@ -0,0 +1,19 @@ +supplier { # Supplier + n1: circle label:"Start Container Loading" + n3: diamond label:"Review Container Loading details" + n5: rectangle label:"Update records for Container Loading" + n7: circle label:"End Container Loading" + n1.handle(bottom) -> warehouse.n2.handle(top) + n3.handle(bottom) -> warehouse.n4.handle(top) + n3.handle(right) -> warehouse.n2.handle(right) [label="Retry/Rejected"] + n5.handle(bottom) -> warehouse.n6.handle(top) [label="Done"] +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Container Loading request" + n4: rectangle label:"Make Container Loading decision" + n6: rectangle label:"Continue Container Loading process" + n6.handle(right) -> supplier.n7.handle(bottom) + n4.handle(right) -> supplier.n5.handle(left) + n2.handle(bottom) -> supplier.n3.handle(left) [label="Next"] +} diff --git a/uncategorized/logistics/cross-docking-workflow/README.md b/uncategorized/logistics/cross-docking-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bc14687648b557f2dd529fd69fcb0b1019f6ceaf --- /dev/null +++ b/uncategorized/logistics/cross-docking-workflow/README.md @@ -0,0 +1,19 @@ +# Cross Docking Workflow + +Cross-docking workflow with inbound scheduling, sortation by destination, outbound consolidation, and direct transfer without storage for just-in-time delivery. + +**Template ID:** `cross-docking-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [cross-docking, flow-through, dock-scheduling, sortation, consolidation, just-in-time] +**Source path:** `logistics/cross-docking` +**Repo path:** `uncategorized/logistics/cross-docking-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/cross-docking-workflow/metadata.json b/uncategorized/logistics/cross-docking-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..47eb1ecee476bd9d72d294d3f3f5e589deb17c2d --- /dev/null +++ b/uncategorized/logistics/cross-docking-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "cross-docking-workflow", + "workflow_id": "cross-docking", + "title": "Cross Docking Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "cross-docking", + "flow-through", + "dock-scheduling", + "sortation", + "consolidation", + "just-in-time" + ], + "description": "Cross-docking workflow with inbound scheduling, sortation by destination, outbound consolidation, and direct transfer without storage for just-in-time delivery.", + "source_path": "logistics/cross-docking", + "repo_path": "uncategorized/logistics/cross-docking-workflow" +} diff --git a/uncategorized/logistics/cross-docking-workflow/workflow.fz b/uncategorized/logistics/cross-docking-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b1877fc0906947c74c521f7e0e1e6eae290db978 --- /dev/null +++ b/uncategorized/logistics/cross-docking-workflow/workflow.fz @@ -0,0 +1,27 @@ +supplier { # Supplier + n1: circle label:"Start Cross Docking" + n4: rectangle label:"Make Cross Docking decision" + n7: rectangle label:"Continue Cross Docking process" + n10: circle label:"End Cross Docking" + n1.handle(bottom) -> warehouse.n2.handle(top) [label="Success"] + n4.handle(bottom) -> warehouse.n5.handle(top) [label="Valid"] + n7.handle(bottom) -> warehouse.n8.handle(top) [label="Next"] +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Cross Docking request" + n5: rectangle label:"Update records for Cross Docking" + n8: rectangle label:"Continue Cross Docking process" + n2.handle(bottom) -> iot_sensor.n3.handle(top) + n5.handle(bottom) -> iot_sensor.n6.handle(top) + n8.handle(bottom) -> iot_sensor.n9.handle(top) +} + +iot_sensor { # Iot_Sensor + n3: rectangle label:"Review Cross Docking details" + n6: rectangle label:"Continue Cross Docking process" + n9: rectangle label:"Continue Cross Docking process" + n9.handle(right) -> supplier.n10.handle(bottom) + n6.handle(right) -> supplier.n7.handle(left) + n3.handle(right) -> supplier.n4.handle(left) +} diff --git a/uncategorized/logistics/customs-clearance-workflow/README.md b/uncategorized/logistics/customs-clearance-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5cdf0689640a48ff38bfe87b7af46b2c411c496f --- /dev/null +++ b/uncategorized/logistics/customs-clearance-workflow/README.md @@ -0,0 +1,19 @@ +# Customs Clearance Workflow + +International customs clearance workflow with importer documentation, customs broker HS code classification, duty calculation, customs authority inspection, and clearance certificate issuance. + +**Template ID:** `customs-clearance-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 3 +**Tags:** [customs-clearance, international-trade, customs-broker, hs-codes, import-export, duties-taxes, inspection] +**Source path:** `logistics/customs-clearance` +**Repo path:** `uncategorized/logistics/customs-clearance-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/customs-clearance-workflow/metadata.json b/uncategorized/logistics/customs-clearance-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4f8cdcd186913108d23daa06a628c0981ab004dc --- /dev/null +++ b/uncategorized/logistics/customs-clearance-workflow/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "customs-clearance-workflow", + "workflow_id": "customs-clearance", + "title": "Customs Clearance Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 3, + "tags": [ + "customs-clearance", + "international-trade", + "customs-broker", + "hs-codes", + "import-export", + "duties-taxes", + "inspection" + ], + "description": "International customs clearance workflow with importer documentation, customs broker HS code classification, duty calculation, customs authority inspection, and clearance certificate issuance.", + "source_path": "logistics/customs-clearance", + "repo_path": "uncategorized/logistics/customs-clearance-workflow" +} diff --git a/uncategorized/logistics/customs-clearance-workflow/workflow.fz b/uncategorized/logistics/customs-clearance-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..62569bec80900a3db0f96808f2646bbd874d2bbb --- /dev/null +++ b/uncategorized/logistics/customs-clearance-workflow/workflow.fz @@ -0,0 +1,46 @@ +Importer { # Importer +n1: circle label:"Start" +n2: rectangle label:"Submit shipment details" +n3: rectangle label:"Provide commercial invoice" +n4: rectangle label:"Receive clearance status" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Broker.n6.handle(top) [label="Submit docs"] +n4.handle(right) -> n5.handle(left) +} +Broker { # Customs Broker +n6: rectangle label:"Review documentation" +n7: rectangle label:"Classify HS codes" +n8: rectangle label:"Calculate duties and taxes" +n9: diamond label:"Documents complete?" +n10: rectangle label:"File customs entry" +n11: rectangle label:"Request missing documents" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n11.handle(top) [label="No"] +n10.handle(bottom) -> Customs.n12.handle(top) [label="Submit"] +n11.handle(top) -> Importer.n3.handle(bottom) [label="Request"] +} +Customs { # Customs Authority +n12: rectangle label:"Receive entry filing" +n13: diamond label:"Inspection required?" +n14: rectangle label:"Physical examination" +n15: rectangle label:"Document review only" +n16: diamond label:"Cleared?" +n17: rectangle label:"Release shipment" +n18: rectangle label:"Hold for investigation" +n19: rectangle label:"Issue clearance certificate" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Yes"] +n13.handle(bottom) -> n15.handle(top) [label="No"] +n14.handle(right) -> n16.handle(left) +n15.handle(right) -> n16.handle(top) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> n18.handle(top) [label="No"] +n17.handle(right) -> n19.handle(left) +n18.handle(top) -> Broker.n6.handle(bottom) [label="Resolve"] +n19.handle(top) -> Importer.n4.handle(bottom) [label="Cleared"] +} diff --git a/uncategorized/logistics/damaged-goods-workflow/README.md b/uncategorized/logistics/damaged-goods-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bca7aab84e29c8d456114fc994a45995c42adad8 --- /dev/null +++ b/uncategorized/logistics/damaged-goods-workflow/README.md @@ -0,0 +1,19 @@ +# Damaged Goods Workflow + +Damaged goods processing workflow with damage documentation, carrier claim filing, disposition decision (salvage/dispose), inventory adjustment, and loss tracking. + +**Template ID:** `damaged-goods-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [damaged-goods, damage-claim, inventory-write-off, carrier-claim, disposition, loss-prevention] +**Source path:** `logistics/damaged-goods` +**Repo path:** `uncategorized/logistics/damaged-goods-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/damaged-goods-workflow/metadata.json b/uncategorized/logistics/damaged-goods-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..fb686d929b485d8c557ea6ec96e0fcc0760dfacb --- /dev/null +++ b/uncategorized/logistics/damaged-goods-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "damaged-goods-workflow", + "workflow_id": "damaged-goods", + "title": "Damaged Goods Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "damaged-goods", + "damage-claim", + "inventory-write-off", + "carrier-claim", + "disposition", + "loss-prevention" + ], + "description": "Damaged goods processing workflow with damage documentation, carrier claim filing, disposition decision (salvage/dispose), inventory adjustment, and loss tracking.", + "source_path": "logistics/damaged-goods", + "repo_path": "uncategorized/logistics/damaged-goods-workflow" +} diff --git a/uncategorized/logistics/damaged-goods-workflow/workflow.fz b/uncategorized/logistics/damaged-goods-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..7edd000df38bf40f825230a5185c22837e186d32 --- /dev/null +++ b/uncategorized/logistics/damaged-goods-workflow/workflow.fz @@ -0,0 +1,19 @@ +supplier { # Supplier + n1: circle label:"Start Damaged Goods" + n2: diamond label:"Receive Damaged Goods request" + n3: rectangle label:"Review Damaged Goods details" + n5: rectangle label:"Update records for Damaged Goods" + n7: circle label:"End Damaged Goods" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> warehouse.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> warehouse.n6.handle(top) +} + +warehouse { # Warehouse + n4: rectangle label:"Make Damaged Goods decision" + n6: rectangle label:"Continue Damaged Goods process" + n6.handle(right) -> supplier.n7.handle(bottom) + n4.handle(right) -> supplier.n5.handle(top) +} diff --git a/uncategorized/logistics/delivery-confirmation-workflow/README.md b/uncategorized/logistics/delivery-confirmation-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..44dc6077f0fb1de0e051444d166975f308776055 --- /dev/null +++ b/uncategorized/logistics/delivery-confirmation-workflow/README.md @@ -0,0 +1,19 @@ +# Delivery Confirmation Workflow + +Delivery confirmation workflow with proof of delivery capture, signature collection, photo documentation, order status update, and customer notification. + +**Template ID:** `delivery-confirmation-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [delivery-confirmation, pod, signature-capture, order-completion, customer-notification, tracking-update] +**Source path:** `logistics/delivery-confirmation` +**Repo path:** `uncategorized/logistics/delivery-confirmation-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/delivery-confirmation-workflow/metadata.json b/uncategorized/logistics/delivery-confirmation-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..5827bdfdde7292689d16da04fcc9997f99634fd7 --- /dev/null +++ b/uncategorized/logistics/delivery-confirmation-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "delivery-confirmation-workflow", + "workflow_id": "delivery-confirmation", + "title": "Delivery Confirmation Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "delivery-confirmation", + "pod", + "signature-capture", + "order-completion", + "customer-notification", + "tracking-update" + ], + "description": "Delivery confirmation workflow with proof of delivery capture, signature collection, photo documentation, order status update, and customer notification.", + "source_path": "logistics/delivery-confirmation", + "repo_path": "uncategorized/logistics/delivery-confirmation-workflow" +} diff --git a/uncategorized/logistics/delivery-confirmation-workflow/workflow.fz b/uncategorized/logistics/delivery-confirmation-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..23c2bbba3240703b99c36796ad255eef028cf6d7 --- /dev/null +++ b/uncategorized/logistics/delivery-confirmation-workflow/workflow.fz @@ -0,0 +1,19 @@ +supplier { # Supplier + n1: circle label:"Start Delivery Confirmation" + n3: rectangle label:"Review Delivery Confirmation details" + n5: diamond label:"Update records for Delivery Confirmation" + n7: circle label:"End Delivery Confirmation" + n1.handle(bottom) -> warehouse.n2.handle(top) + n3.handle(bottom) -> warehouse.n4.handle(top) [label="Processed"] + n5.handle(bottom) -> warehouse.n6.handle(top) + n5.handle(right) -> warehouse.n4.handle(right) [label="Retry/Rejected"] +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Delivery Confirmation request" + n4: rectangle label:"Make Delivery Confirmation decision" + n6: rectangle label:"Continue Delivery Confirmation process" + n6.handle(right) -> supplier.n7.handle(bottom) [label="Success"] + n4.handle(bottom) -> supplier.n5.handle(left) + n2.handle(right) -> supplier.n3.handle(left) +} diff --git a/uncategorized/logistics/inventory-receipt-workflow/README.md b/uncategorized/logistics/inventory-receipt-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5e93de22a33520a51956be2216d7f5496dbe87fa --- /dev/null +++ b/uncategorized/logistics/inventory-receipt-workflow/README.md @@ -0,0 +1,19 @@ +# Inventory Receipt Workflow + +Inventory receiving workflow with ASN verification, PO matching, quantity count, damage inspection, and WMS inventory update. + +**Template ID:** `inventory-receipt-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [inventory-receipt, goods-receiving, po-matching, asn-verification, dock-scheduling, wms] +**Source path:** `logistics/inventory-receipt` +**Repo path:** `uncategorized/logistics/inventory-receipt-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/inventory-receipt-workflow/metadata.json b/uncategorized/logistics/inventory-receipt-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8414f235fb26e27f29424786e36299f2f23b3722 --- /dev/null +++ b/uncategorized/logistics/inventory-receipt-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "inventory-receipt-workflow", + "workflow_id": "inventory-receipt", + "title": "Inventory Receipt Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "inventory-receipt", + "goods-receiving", + "po-matching", + "asn-verification", + "dock-scheduling", + "wms" + ], + "description": "Inventory receiving workflow with ASN verification, PO matching, quantity count, damage inspection, and WMS inventory update.", + "source_path": "logistics/inventory-receipt", + "repo_path": "uncategorized/logistics/inventory-receipt-workflow" +} diff --git a/uncategorized/logistics/inventory-receipt-workflow/workflow.fz b/uncategorized/logistics/inventory-receipt-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..7c7075cfa655457c1d6626678f3eefbda5c9643b --- /dev/null +++ b/uncategorized/logistics/inventory-receipt-workflow/workflow.fz @@ -0,0 +1,50 @@ +Receiving { # Receiving Dock +n1: circle label:"Start" +n2: rectangle label:"Truck arrives at dock" +n3: rectangle label:"Verify PO number" +n4: diamond label:"PO exists?" +n5: rectangle label:"Unload shipment" +n6: rectangle label:"Reject delivery" +n7: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="Yes"] +n4.handle(bottom) -> n6.handle(top) [label="No"] +n5.handle(bottom) -> QualityInspection.n8.handle(top) [label="Inspect"] +n6.handle(right) -> n7.handle(left) +} +QualityInspection { # Quality Inspection +n8: rectangle label:"Count received items" +n9: diamond label:"Quantity matches PO?" +n10: rectangle label:"Inspect for damage" +n11: rectangle label:"Log quantity variance" +n12: diamond label:"Quality acceptable?" +n13: rectangle label:"Accept goods" +n14: rectangle label:"Quarantine items" +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n11.handle(top) [label="No"] +n10.handle(right) -> n12.handle(left) +n11.handle(right) -> n10.handle(top) +n12.handle(right) -> n13.handle(left) [label="Yes"] +n12.handle(bottom) -> n14.handle(top) [label="No"] +n13.handle(bottom) -> Putaway.n15.handle(top) [label="Store"] +n14.handle(bottom) -> Putaway.n20.handle(top) [label="Hold"] +} +Putaway { # Putaway Process +n15: rectangle label:"Generate putaway task" +n16: rectangle label:"Assign storage location" +n17: rectangle label:"Move to bin location" +n18: rectangle label:"Scan bin and item" +n19: rectangle label:"Update inventory system" +n20: rectangle label:"Move to quarantine zone" +n21: rectangle label:"Create vendor claim" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> Receiving.n7.handle(bottom) [label="Complete"] +n20.handle(right) -> n21.handle(left) +n21.handle(top) -> Receiving.n7.handle(bottom) [label="Claim filed"] +} diff --git a/uncategorized/logistics/kitting-process-workflow/README.md b/uncategorized/logistics/kitting-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3df1f1210b8c8ac6f8916f5caf5c1754c0f851e6 --- /dev/null +++ b/uncategorized/logistics/kitting-process-workflow/README.md @@ -0,0 +1,19 @@ +# Kitting Process Workflow + +Kit assembly workflow with BOM explosion, component picking, assembly verification, kit labeling, and inventory conversion from components to finished kit. + +**Template ID:** `kitting-process-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [kitting-process, kit-assembly, bom, component-picking, value-added-services, bundling] +**Source path:** `logistics/kitting-process` +**Repo path:** `uncategorized/logistics/kitting-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/kitting-process-workflow/metadata.json b/uncategorized/logistics/kitting-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bac15dcc50deb9ccda871316ecef7fd383a81b92 --- /dev/null +++ b/uncategorized/logistics/kitting-process-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "kitting-process-workflow", + "workflow_id": "kitting-process", + "title": "Kitting Process Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "kitting-process", + "kit-assembly", + "bom", + "component-picking", + "value-added-services", + "bundling" + ], + "description": "Kit assembly workflow with BOM explosion, component picking, assembly verification, kit labeling, and inventory conversion from components to finished kit.", + "source_path": "logistics/kitting-process", + "repo_path": "uncategorized/logistics/kitting-process-workflow" +} diff --git a/uncategorized/logistics/kitting-process-workflow/workflow.fz b/uncategorized/logistics/kitting-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..85fcde381e5ff38398c251ff0d069bf60c68c413 --- /dev/null +++ b/uncategorized/logistics/kitting-process-workflow/workflow.fz @@ -0,0 +1,19 @@ +supplier { # Supplier + n1: circle label:"Start Kitting Process" + n3: diamond label:"Review Kitting Process details" + n5: rectangle label:"Update records for Kitting Process" + n7: circle label:"End Kitting Process" + n1.handle(bottom) -> warehouse.n2.handle(top) + n3.handle(bottom) -> warehouse.n4.handle(top) + n3.handle(right) -> warehouse.n2.handle(right) [label="Retry/Rejected"] + n5.handle(bottom) -> warehouse.n6.handle(top) [label="Done"] +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Kitting Process request" + n4: rectangle label:"Make Kitting Process decision" + n6: rectangle label:"Continue Kitting Process process" + n6.handle(right) -> supplier.n7.handle(bottom) + n4.handle(right) -> supplier.n5.handle(left) + n2.handle(bottom) -> supplier.n3.handle(left) [label="Next"] +} diff --git a/uncategorized/logistics/last-mile-delivery-workflow/README.md b/uncategorized/logistics/last-mile-delivery-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..921cc7e7c7067127a811e458fc6fe8789afd87c7 --- /dev/null +++ b/uncategorized/logistics/last-mile-delivery-workflow/README.md @@ -0,0 +1,19 @@ +# Last Mile Delivery Workflow + +Last mile delivery workflow with route optimization, real-time GPS tracking, delivery attempt handling, proof of delivery capture, and customer notification. + +**Template ID:** `last-mile-delivery-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [last-mile-delivery, route-optimization, proof-of-delivery, delivery-exception, customer-notification, gps-tracking] +**Source path:** `logistics/last-mile-delivery` +**Repo path:** `uncategorized/logistics/last-mile-delivery-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/last-mile-delivery-workflow/metadata.json b/uncategorized/logistics/last-mile-delivery-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..5e27a36b0d73427485eee8d24fbca663899958b7 --- /dev/null +++ b/uncategorized/logistics/last-mile-delivery-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "last-mile-delivery-workflow", + "workflow_id": "last-mile-delivery", + "title": "Last Mile Delivery Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "last-mile-delivery", + "route-optimization", + "proof-of-delivery", + "delivery-exception", + "customer-notification", + "gps-tracking" + ], + "description": "Last mile delivery workflow with route optimization, real-time GPS tracking, delivery attempt handling, proof of delivery capture, and customer notification.", + "source_path": "logistics/last-mile-delivery", + "repo_path": "uncategorized/logistics/last-mile-delivery-workflow" +} diff --git a/uncategorized/logistics/last-mile-delivery-workflow/workflow.fz b/uncategorized/logistics/last-mile-delivery-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..5357097396d2d37f32dadf2c189901d41c457ae7 --- /dev/null +++ b/uncategorized/logistics/last-mile-delivery-workflow/workflow.fz @@ -0,0 +1,50 @@ +DispatchCenter { # Dispatch Center +n1: circle label:"Start" +n2: rectangle label:"Receive delivery batch" +n3: rectangle label:"Optimize delivery routes" +n4: rectangle label:"Assign to driver" +n5: rectangle label:"Update delivery status" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(bottom) -> Driver.n7.handle(top) [label="Dispatch"] +n5.handle(right) -> n6.handle(left) +} +Driver { # Delivery Driver +n7: rectangle label:"Load packages into van" +n8: rectangle label:"Navigate to address" +n9: rectangle label:"Arrive at location" +n10: diamond label:"Customer available?" +n11: rectangle label:"Deliver to customer" +n12: rectangle label:"Capture signature" +n13: diamond label:"Safe drop location?" +n14: rectangle label:"Leave at door" +n15: rectangle label:"Attempt redelivery" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n13.handle(top) [label="No"] +n11.handle(right) -> n12.handle(left) +n12.handle(bottom) -> Confirmation.n16.handle(top) [label="Signed"] +n13.handle(right) -> n14.handle(left) [label="Yes"] +n13.handle(bottom) -> n15.handle(top) [label="No"] +n14.handle(bottom) -> Confirmation.n16.handle(top) [label="Photo proof"] +n15.handle(bottom) -> Confirmation.n20.handle(top) [label="Failed"] +} +Confirmation { # Delivery Confirmation +n16: rectangle label:"Take delivery photo" +n17: rectangle label:"Update GPS coordinates" +n18: rectangle label:"Mark as delivered" +n19: rectangle label:"Send customer notification" +n20: rectangle label:"Schedule redelivery" +n21: diamond label:"More stops?" +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(right) -> n21.handle(left) +n20.handle(top) -> DispatchCenter.n5.handle(bottom) [label="Rescheduled"] +n21.handle(right) -> Driver.n8.handle(bottom) [label="Yes"] +n21.handle(bottom) -> DispatchCenter.n5.handle(top) [label="No"] +} diff --git a/uncategorized/logistics/packing-process-workflow/README.md b/uncategorized/logistics/packing-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..94ea088c278e98dfa98b3526a881ec6e6762d33b --- /dev/null +++ b/uncategorized/logistics/packing-process-workflow/README.md @@ -0,0 +1,19 @@ +# Packing Process Workflow + +Order packing workflow with carton selection, item verification, packing slip insertion, weight check, and package sealing for shipment. + +**Template ID:** `packing-process-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [order-packing, box-selection, packing-slip, weight-verification, cartonization, fulfillment] +**Source path:** `logistics/packing-process` +**Repo path:** `uncategorized/logistics/packing-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/packing-process-workflow/metadata.json b/uncategorized/logistics/packing-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bb1a3cac02be5a09a08570e2f8bb216c22bd6524 --- /dev/null +++ b/uncategorized/logistics/packing-process-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "packing-process-workflow", + "workflow_id": "packing-process", + "title": "Packing Process Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "order-packing", + "box-selection", + "packing-slip", + "weight-verification", + "cartonization", + "fulfillment" + ], + "description": "Order packing workflow with carton selection, item verification, packing slip insertion, weight check, and package sealing for shipment.", + "source_path": "logistics/packing-process", + "repo_path": "uncategorized/logistics/packing-process-workflow" +} diff --git a/uncategorized/logistics/packing-process-workflow/workflow.fz b/uncategorized/logistics/packing-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..337a210565d69cd4ac9a7a7bf69feb2d4eed9a1b --- /dev/null +++ b/uncategorized/logistics/packing-process-workflow/workflow.fz @@ -0,0 +1,19 @@ +supplier { # Supplier + n1: circle label:"Start Packing Process" + n3: diamond label:"Review Packing Process details" + n5: rectangle label:"Update records for Packing Process" + n7: circle label:"End Packing Process" + n1.handle(bottom) -> warehouse.n2.handle(top) + n3.handle(bottom) -> warehouse.n4.handle(top) [label="Processed"] + n3.handle(right) -> warehouse.n2.handle(right) [label="Retry/Rejected"] + n5.handle(bottom) -> warehouse.n6.handle(top) +} + +warehouse { # Warehouse + n2: rectangle label:"Receive Packing Process request" + n4: rectangle label:"Make Packing Process decision" + n6: rectangle label:"Continue Packing Process process" + n6.handle(right) -> supplier.n7.handle(bottom) [label="Success"] + n4.handle(right) -> supplier.n5.handle(left) + n2.handle(bottom) -> supplier.n3.handle(left) +} diff --git a/uncategorized/logistics/picking-process-workflow/README.md b/uncategorized/logistics/picking-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b02626c315d567e4d4b6c29e0ca29ee6ff51c9ab --- /dev/null +++ b/uncategorized/logistics/picking-process-workflow/README.md @@ -0,0 +1,19 @@ +# Picking Process Workflow + +Warehouse order picking workflow with pick list generation, zone routing, batch picking optimization, barcode scanning verification, and pick completion confirmation. + +**Template ID:** `picking-process-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [order-picking, warehouse-management, pick-list, batch-picking, wave-picking, wms] +**Source path:** `logistics/picking-process` +**Repo path:** `uncategorized/logistics/picking-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/picking-process-workflow/metadata.json b/uncategorized/logistics/picking-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f233ce3017d09b654535a10d7c2a9f87e78e28c1 --- /dev/null +++ b/uncategorized/logistics/picking-process-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "picking-process-workflow", + "workflow_id": "picking-process", + "title": "Picking Process Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "order-picking", + "warehouse-management", + "pick-list", + "batch-picking", + "wave-picking", + "wms" + ], + "description": "Warehouse order picking workflow with pick list generation, zone routing, batch picking optimization, barcode scanning verification, and pick completion confirmation.", + "source_path": "logistics/picking-process", + "repo_path": "uncategorized/logistics/picking-process-workflow" +} diff --git a/uncategorized/logistics/picking-process-workflow/workflow.fz b/uncategorized/logistics/picking-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..727d2482e46da7b26c77028d5a2b331f041ac315 --- /dev/null +++ b/uncategorized/logistics/picking-process-workflow/workflow.fz @@ -0,0 +1,48 @@ +WMS { # Warehouse Management System +n1: circle label:"Start" +n2: rectangle label:"Receive pick wave" +n3: rectangle label:"Optimize pick route" +n4: rectangle label:"Assign to picker" +n5: rectangle label:"Update wave status" +n6: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(bottom) -> Picker.n7.handle(top) [label="Dispatch"] +n5.handle(right) -> n6.handle(left) +} +Picker { # Warehouse Picker +n7: rectangle label:"Receive pick list on scanner" +n8: rectangle label:"Navigate to location" +n9: rectangle label:"Scan bin barcode" +n10: diamond label:"Correct location?" +n11: rectangle label:"Pick quantity" +n12: rectangle label:"Scan item barcode" +n13: diamond label:"Correct item?" +n14: rectangle label:"Place in tote" +n15: rectangle label:"Report location error" +n16: rectangle label:"Report item mismatch" +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n15.handle(top) [label="No"] +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) [label="Yes"] +n13.handle(bottom) -> n16.handle(top) [label="No"] +n14.handle(bottom) -> QualityCheck.n17.handle(top) [label="Item picked"] +n15.handle(top) -> n8.handle(bottom) [label="Redirect"] +n16.handle(top) -> n11.handle(bottom) [label="Repick"] +} +QualityCheck { # Quality Check +n17: diamond label:"More items in order?" +n18: rectangle label:"Move to next location" +n19: rectangle label:"Complete pick task" +n20: rectangle label:"Scan tote to packing" +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(top) -> Picker.n8.handle(bottom) [label="Continue"] +n19.handle(right) -> n20.handle(left) +n20.handle(top) -> WMS.n5.handle(bottom) [label="Complete"] +} diff --git a/uncategorized/logistics/put-away-process-workflow/README.md b/uncategorized/logistics/put-away-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b07ded8bf3cc2008302680325cb428aa96cd8475 --- /dev/null +++ b/uncategorized/logistics/put-away-process-workflow/README.md @@ -0,0 +1,19 @@ +# Put Away Process Workflow + +Warehouse put-away workflow with location assignment, slotting optimization, forklift routing, barcode confirmation, and WMS location update. + +**Template ID:** `put-away-process-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [put-away, warehouse-storage, location-assignment, slotting, wms, inventory-placement] +**Source path:** `logistics/put-away-process` +**Repo path:** `uncategorized/logistics/put-away-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/put-away-process-workflow/metadata.json b/uncategorized/logistics/put-away-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4180b5fc9e66af955a838c53d4440357c71cdcc8 --- /dev/null +++ b/uncategorized/logistics/put-away-process-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "put-away-process-workflow", + "workflow_id": "put-away-process", + "title": "Put Away Process Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "put-away", + "warehouse-storage", + "location-assignment", + "slotting", + "wms", + "inventory-placement" + ], + "description": "Warehouse put-away workflow with location assignment, slotting optimization, forklift routing, barcode confirmation, and WMS location update.", + "source_path": "logistics/put-away-process", + "repo_path": "uncategorized/logistics/put-away-process-workflow" +} diff --git a/uncategorized/logistics/put-away-process-workflow/workflow.fz b/uncategorized/logistics/put-away-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..590456e7c680c0f6970752cbbfbe6e9a70f86b6d --- /dev/null +++ b/uncategorized/logistics/put-away-process-workflow/workflow.fz @@ -0,0 +1,19 @@ +supplier { # Supplier + n1: circle label:"Start Put Away Process" + n2: diamond label:"Receive Put Away Process request" + n3: rectangle label:"Review Put Away Process details" + n5: rectangle label:"Update records for Put Away Process" + n7: circle label:"End Put Away Process" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> warehouse.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> warehouse.n6.handle(top) +} + +warehouse { # Warehouse + n4: rectangle label:"Make Put Away Process decision" + n6: rectangle label:"Continue Put Away Process process" + n6.handle(right) -> supplier.n7.handle(bottom) + n4.handle(right) -> supplier.n5.handle(top) +} diff --git a/uncategorized/logistics/quality-inspection-workflow/README.md b/uncategorized/logistics/quality-inspection-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e8d4efb2f6266376778dd6551d15775fdb4084c3 --- /dev/null +++ b/uncategorized/logistics/quality-inspection-workflow/README.md @@ -0,0 +1,19 @@ +# Quality Inspection Workflow + +Incoming quality inspection workflow with AQL sampling, defect classification, hold/release decision, supplier notification, and quality metrics tracking. + +**Template ID:** `quality-inspection-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [quality-inspection, incoming-inspection, aql-sampling, defect-tracking, supplier-quality, hold-release] +**Source path:** `logistics/quality-inspection` +**Repo path:** `uncategorized/logistics/quality-inspection-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/quality-inspection-workflow/metadata.json b/uncategorized/logistics/quality-inspection-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7b00fcf516724f867f668681af744faacefe2012 --- /dev/null +++ b/uncategorized/logistics/quality-inspection-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "quality-inspection-workflow", + "workflow_id": "quality-inspection", + "title": "Quality Inspection Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "quality-inspection", + "incoming-inspection", + "aql-sampling", + "defect-tracking", + "supplier-quality", + "hold-release" + ], + "description": "Incoming quality inspection workflow with AQL sampling, defect classification, hold/release decision, supplier notification, and quality metrics tracking.", + "source_path": "logistics/quality-inspection", + "repo_path": "uncategorized/logistics/quality-inspection-workflow" +} diff --git a/uncategorized/logistics/quality-inspection-workflow/workflow.fz b/uncategorized/logistics/quality-inspection-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..eed098f314205c5e59ec8c372a2ba8d9a330d96a --- /dev/null +++ b/uncategorized/logistics/quality-inspection-workflow/workflow.fz @@ -0,0 +1,48 @@ +Receiving { # Receiving +n1: circle label:"Start" +n2: rectangle label:"Select items for inspection" +n3: rectangle label:"Generate inspection lot" +n4: rectangle label:"Record inspection results" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Inspector.n6.handle(top) [label="Inspect"] +n4.handle(right) -> n5.handle(left) +} +Inspector { # Quality Inspector +n6: rectangle label:"Review inspection criteria" +n7: rectangle label:"Perform visual inspection" +n8: rectangle label:"Take measurements" +n9: diamond label:"Within tolerance?" +n10: rectangle label:"Test functionality" +n11: rectangle label:"Document defects" +n12: diamond label:"Defect severity?" +n13: rectangle label:"Mark as passed" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n11.handle(top) [label="No"] +n10.handle(right) -> n13.handle(left) +n11.handle(right) -> n12.handle(left) +n12.handle(right) -> Disposition.n14.handle(left) [label="Minor"] +n12.handle(bottom) -> Disposition.n17.handle(top) [label="Major"] +n13.handle(bottom) -> Disposition.n14.handle(top) [label="Accept"] +} +Disposition { # Disposition +n14: rectangle label:"Accept with deviation" +n15: rectangle label:"Move to inventory" +n16: rectangle label:"Update quality records" +n17: rectangle label:"Reject lot" +n18: diamond label:"Return or scrap?" +n19: rectangle label:"Create return to vendor" +n20: rectangle label:"Schedule for scrap" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(top) -> Receiving.n4.handle(bottom) [label="Complete"] +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) [label="Return"] +n18.handle(bottom) -> n20.handle(top) [label="Scrap"] +n19.handle(top) -> Receiving.n4.handle(bottom) [label="RTV created"] +n20.handle(top) -> Receiving.n4.handle(bottom) [label="Scrapped"] +} diff --git a/uncategorized/logistics/reorder-process-workflow/README.md b/uncategorized/logistics/reorder-process-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fcc13a5e0c22d0eeadc57947890dccb6857adada --- /dev/null +++ b/uncategorized/logistics/reorder-process-workflow/README.md @@ -0,0 +1,19 @@ +# Reorder Process Workflow + +Inventory reorder workflow with reorder point monitoring, economic order quantity calculation, safety stock consideration, and automatic purchase requisition generation. + +**Template ID:** `reorder-process-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [reorder-process, reorder-point, safety-stock, eoq, demand-planning, auto-replenishment] +**Source path:** `logistics/reorder-process` +**Repo path:** `uncategorized/logistics/reorder-process-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/reorder-process-workflow/metadata.json b/uncategorized/logistics/reorder-process-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ec69ff82566732752cccf2eb702ecf510f948eec --- /dev/null +++ b/uncategorized/logistics/reorder-process-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "reorder-process-workflow", + "workflow_id": "reorder-process", + "title": "Reorder Process Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "reorder-process", + "reorder-point", + "safety-stock", + "eoq", + "demand-planning", + "auto-replenishment" + ], + "description": "Inventory reorder workflow with reorder point monitoring, economic order quantity calculation, safety stock consideration, and automatic purchase requisition generation.", + "source_path": "logistics/reorder-process", + "repo_path": "uncategorized/logistics/reorder-process-workflow" +} diff --git a/uncategorized/logistics/reorder-process-workflow/workflow.fz b/uncategorized/logistics/reorder-process-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..2c9dd24877c2370df855d90d6175b7134ca0cb79 --- /dev/null +++ b/uncategorized/logistics/reorder-process-workflow/workflow.fz @@ -0,0 +1,19 @@ +supplier { # Supplier + n1: circle label:"Start Reorder Process" + n2: diamond label:"Receive Reorder Process request" + n3: rectangle label:"Review Reorder Process details" + n5: rectangle label:"Update records for Reorder Process" + n7: circle label:"End Reorder Process" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> warehouse.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> warehouse.n6.handle(top) +} + +warehouse { # Warehouse + n4: rectangle label:"Make Reorder Process decision" + n6: rectangle label:"Continue Reorder Process process" + n6.handle(right) -> supplier.n7.handle(bottom) + n4.handle(right) -> supplier.n5.handle(top) +} diff --git a/uncategorized/logistics/reverse-logistics-workflow/README.md b/uncategorized/logistics/reverse-logistics-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a1a4d6f8ecc3d836355790e9d68c925fbc72e33a --- /dev/null +++ b/uncategorized/logistics/reverse-logistics-workflow/README.md @@ -0,0 +1,19 @@ +# Reverse Logistics Workflow + +Reverse logistics workflow with return authorization, product grading, refurbishment decision, recycling coordination, and secondary market disposition. + +**Template ID:** `reverse-logistics-workflow` +**Kind:** workflow +**Source domain:** logistics +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [reverse-logistics, product-returns, refurbishment, recycling, disposition, sustainability] +**Source path:** `logistics/reverse-logistics` +**Repo path:** `uncategorized/logistics/reverse-logistics-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/logistics/reverse-logistics-workflow/metadata.json b/uncategorized/logistics/reverse-logistics-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..a12a590127a6a3fbe6e7456cda552a5f8c4e9bd5 --- /dev/null +++ b/uncategorized/logistics/reverse-logistics-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "reverse-logistics-workflow", + "workflow_id": "reverse-logistics", + "title": "Reverse Logistics Workflow", + "kind": "workflow", + "source_domain": "logistics", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "reverse-logistics", + "product-returns", + "refurbishment", + "recycling", + "disposition", + "sustainability" + ], + "description": "Reverse logistics workflow with return authorization, product grading, refurbishment decision, recycling coordination, and secondary market disposition.", + "source_path": "logistics/reverse-logistics", + "repo_path": "uncategorized/logistics/reverse-logistics-workflow" +} diff --git a/uncategorized/logistics/reverse-logistics-workflow/workflow.fz b/uncategorized/logistics/reverse-logistics-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..0508f4f4e7361a39fa8a4e76647e1391d6d467dc --- /dev/null +++ b/uncategorized/logistics/reverse-logistics-workflow/workflow.fz @@ -0,0 +1,28 @@ +supplier { # Supplier + n1: circle label:"Start Reverse Logistics" + n2: diamond label:"Receive Reverse Logistics request" + n4: rectangle label:"Make Reverse Logistics decision" + n7: rectangle label:"Continue Reverse Logistics process" + n10: circle label:"End Reverse Logistics" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> iot_sensor.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> warehouse.n5.handle(top) + n7.handle(bottom) -> warehouse.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +warehouse { # Warehouse + n5: rectangle label:"Update records for Reverse Logistics" + n8: rectangle label:"Continue Reverse Logistics process" + n5.handle(bottom) -> iot_sensor.n6.handle(top) + n8.handle(bottom) -> iot_sensor.n9.handle(top) +} + +iot_sensor { # Iot_Sensor + n3: rectangle label:"Review Reverse Logistics details" + n6: rectangle label:"Continue Reverse Logistics process" + n9: rectangle label:"Continue Reverse Logistics process" + n9.handle(right) -> supplier.n10.handle(bottom) + n6.handle(right) -> supplier.n7.handle(left) + n3.handle(left) -> warehouse.n5.handle(left) +} diff --git a/uncategorized/patterns/a-b-testing-workflow/README.md b/uncategorized/patterns/a-b-testing-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a98304a59d1ff77e9fb958e009d8a45a6ab4e4ff --- /dev/null +++ b/uncategorized/patterns/a-b-testing-workflow/README.md @@ -0,0 +1,19 @@ +# A B Testing Workflow + +This workflow models comparing two versions to see which performs better. + +**Template ID:** `a-b-testing-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [a, b, testing, patterns] +**Source path:** `patterns/a-b-testing` +**Repo path:** `uncategorized/patterns/a-b-testing-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/a-b-testing-workflow/metadata.json b/uncategorized/patterns/a-b-testing-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f9b1cde8603cadbd2ea6931fbe20954e12601068 --- /dev/null +++ b/uncategorized/patterns/a-b-testing-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "a-b-testing-workflow", + "workflow_id": "a-b-testing", + "title": "A B Testing Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "a", + "b", + "testing", + "patterns" + ], + "description": "This workflow models comparing two versions to see which performs better.", + "source_path": "patterns/a-b-testing", + "repo_path": "uncategorized/patterns/a-b-testing-workflow" +} diff --git a/uncategorized/patterns/a-b-testing-workflow/workflow.fz b/uncategorized/patterns/a-b-testing-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..07664262ca82f9c3c6ad09435d1df8c8a3645180 --- /dev/null +++ b/uncategorized/patterns/a-b-testing-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start A B Testing" + n4: rectangle label:"Execute A B Testing action" + n7: rectangle label:"Monitor A B Testing status" + n10: circle label:"End A B Testing" + n1.handle(bottom) -> app.n2.handle(top) + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) +} + +app { # App + n2: rectangle label:"Receive A B Testing event" + n5: rectangle label:"Record A B Testing outcome" + n8: rectangle label:"Monitor A B Testing status" + n2.handle(bottom) -> service.n3.handle(top) [label="Next"] + n5.handle(bottom) -> service.n6.handle(top) [label="Done"] + n8.handle(bottom) -> service.n9.handle(top) [label="Processed"] +} + +service { # Service + n3: rectangle label:"Validate A B Testing conditions" + n6: rectangle label:"Monitor A B Testing status" + n9: diamond label:"Monitor A B Testing status" + n3.handle(right) -> user.n4.handle(left) + n6.handle(right) -> user.n7.handle(left) + n9.handle(right) -> user.n10.handle(left) + n9.handle(left) -> app.n8.handle(left) [label="Retry/Rejected"] +} diff --git a/uncategorized/patterns/batch-processing-workflow/README.md b/uncategorized/patterns/batch-processing-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f141810856bbf74219598b33ee613877192d7725 --- /dev/null +++ b/uncategorized/patterns/batch-processing-workflow/README.md @@ -0,0 +1,19 @@ +# Batch Processing Workflow + +Batch processing pattern with job scheduling, chunk-based processing, checkpoint/restart capability, error handling, and completion reporting. + +**Template ID:** `batch-processing-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [batch-processing, scheduled-jobs, bulk-operations, etl, chunk-processing, job-scheduler] +**Source path:** `patterns/batch-processing` +**Repo path:** `uncategorized/patterns/batch-processing-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/batch-processing-workflow/metadata.json b/uncategorized/patterns/batch-processing-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..14f5f649a296978476ffb18aa9d2c359ba6e3a31 --- /dev/null +++ b/uncategorized/patterns/batch-processing-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "batch-processing-workflow", + "workflow_id": "batch-processing", + "title": "Batch Processing Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "batch-processing", + "scheduled-jobs", + "bulk-operations", + "etl", + "chunk-processing", + "job-scheduler" + ], + "description": "Batch processing pattern with job scheduling, chunk-based processing, checkpoint/restart capability, error handling, and completion reporting.", + "source_path": "patterns/batch-processing", + "repo_path": "uncategorized/patterns/batch-processing-workflow" +} diff --git a/uncategorized/patterns/batch-processing-workflow/workflow.fz b/uncategorized/patterns/batch-processing-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..2c7bce1371605d319ca37980edc9416f27f4f6a4 --- /dev/null +++ b/uncategorized/patterns/batch-processing-workflow/workflow.fz @@ -0,0 +1,19 @@ +user { # User + n1: circle label:"Start Batch Processing" + n3: rectangle label:"Validate Batch Processing conditions" + n5: rectangle label:"Record Batch Processing outcome" + n7: circle label:"End Batch Processing" + n1.handle(bottom) -> app.n2.handle(top) + n3.handle(bottom) -> app.n4.handle(top) [label="Processed"] + n5.handle(bottom) -> app.n6.handle(top) +} + +app { # App + n2: rectangle label:"Receive Batch Processing event" + n4: diamond label:"Execute Batch Processing action" + n6: rectangle label:"Monitor Batch Processing status" + n6.handle(right) -> user.n7.handle(left) [label="Success"] + n2.handle(right) -> user.n3.handle(left) + n4.handle(left) -> user.n3.handle(left) [label="Retry/Rejected"] + n4.handle(right) -> user.n5.handle(left) +} diff --git a/uncategorized/patterns/cache-aside-workflow/README.md b/uncategorized/patterns/cache-aside-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2ea722cfe31bd1c79d088ac44f8b7f141f335352 --- /dev/null +++ b/uncategorized/patterns/cache-aside-workflow/README.md @@ -0,0 +1,19 @@ +# Cache Aside Workflow + +Cache-aside pattern with cache lookup, database fallback on miss, cache population, TTL-based expiration, and write-through invalidation. + +**Template ID:** `cache-aside-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [cache-aside, lazy-loading, cache-miss, cache-invalidation, redis, performance] +**Source path:** `patterns/cache-aside` +**Repo path:** `uncategorized/patterns/cache-aside-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/cache-aside-workflow/metadata.json b/uncategorized/patterns/cache-aside-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7d2804e9ed111c72ce20ab2ff67ca22edb3dbc7e --- /dev/null +++ b/uncategorized/patterns/cache-aside-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "cache-aside-workflow", + "workflow_id": "cache-aside", + "title": "Cache Aside Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "cache-aside", + "lazy-loading", + "cache-miss", + "cache-invalidation", + "redis", + "performance" + ], + "description": "Cache-aside pattern with cache lookup, database fallback on miss, cache population, TTL-based expiration, and write-through invalidation.", + "source_path": "patterns/cache-aside", + "repo_path": "uncategorized/patterns/cache-aside-workflow" +} diff --git a/uncategorized/patterns/cache-aside-workflow/workflow.fz b/uncategorized/patterns/cache-aside-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..cfcd791df341f6f68d8deadd602ebe6c6ba6b33d --- /dev/null +++ b/uncategorized/patterns/cache-aside-workflow/workflow.fz @@ -0,0 +1,46 @@ +Application { # Application +n1: circle label:"Start" +n2: rectangle label:"Request data by key" +n3: rectangle label:"Return data to caller" +n4: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> CacheLayer.n5.handle(top) [label="Lookup"] +n3.handle(right) -> n4.handle(left) +} +CacheLayer { # Cache Layer +n5: rectangle label:"Check cache for key" +n6: diamond label:"Cache hit?" +n7: rectangle label:"Return cached value" +n8: rectangle label:"Query database" +n9: rectangle label:"Store in cache with TTL" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n7.handle(left) [label="Yes"] +n6.handle(bottom) -> n8.handle(top) [label="No"] +n7.handle(top) -> Application.n3.handle(bottom) [label="From cache"] +n8.handle(bottom) -> Database.n10.handle(top) [label="Fetch"] +n9.handle(top) -> Application.n3.handle(bottom) [label="From DB"] +} +Database { # Database +n10: rectangle label:"Execute query" +n11: diamond label:"Data found?" +n12: rectangle label:"Return result set" +n13: rectangle label:"Return empty result" +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n13.handle(top) [label="No"] +n12.handle(top) -> CacheLayer.n9.handle(bottom) [label="Populate cache"] +n13.handle(top) -> Application.n3.handle(bottom) [label="Not found"] +} +WriteOperation { # Write Operation +n14: rectangle label:"Update database" +n15: rectangle label:"Invalidate cache key" +n16: diamond label:"Write-through?" +n17: rectangle label:"Update cache directly" +n18: rectangle label:"Let cache expire" +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Yes"] +n16.handle(bottom) -> n18.handle(top) [label="No"] +n17.handle(top) -> Application.n3.handle(bottom) [label="Updated"] +n18.handle(top) -> Application.n3.handle(bottom) [label="Invalidated"] +} diff --git a/uncategorized/patterns/callback-pattern-workflow/README.md b/uncategorized/patterns/callback-pattern-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f9d5ea25cb9f244e06abe6ef9ecfac9dbd31d1bf --- /dev/null +++ b/uncategorized/patterns/callback-pattern-workflow/README.md @@ -0,0 +1,19 @@ +# Callback Pattern Workflow + +This workflow models an async operation that notifies a callback when done. + +**Template ID:** `callback-pattern-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [callback, pattern, patterns, decision, loop] +**Source path:** `patterns/callback-pattern` +**Repo path:** `uncategorized/patterns/callback-pattern-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/callback-pattern-workflow/metadata.json b/uncategorized/patterns/callback-pattern-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bf09b49a24daec3ae4dceaa9f5f4c17615e8b248 --- /dev/null +++ b/uncategorized/patterns/callback-pattern-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "callback-pattern-workflow", + "workflow_id": "callback-pattern", + "title": "Callback Pattern Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "callback", + "pattern", + "patterns", + "decision", + "loop" + ], + "description": "This workflow models an async operation that notifies a callback when done.", + "source_path": "patterns/callback-pattern", + "repo_path": "uncategorized/patterns/callback-pattern-workflow" +} diff --git a/uncategorized/patterns/callback-pattern-workflow/workflow.fz b/uncategorized/patterns/callback-pattern-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9abc27fdfc58c540bc5760775e05c8184f0c1f6d --- /dev/null +++ b/uncategorized/patterns/callback-pattern-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Callback Pattern" + n2: diamond label:"Receive Callback Pattern event" + n4: rectangle label:"Execute Callback Pattern action" + n7: rectangle label:"Monitor Callback Pattern status" + n10: circle label:"End Callback Pattern" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(right) -> app.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +app { # App + n5: rectangle label:"Record Callback Pattern outcome" + n8: rectangle label:"Monitor Callback Pattern status" + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Callback Pattern conditions" + n6: rectangle label:"Monitor Callback Pattern status" + n9: rectangle label:"Monitor Callback Pattern status" + n9.handle(right) -> user.n10.handle(bottom) + n6.handle(right) -> user.n7.handle(bottom) + n3.handle(left) -> app.n5.handle(left) +} diff --git a/uncategorized/patterns/claim-check-workflow/README.md b/uncategorized/patterns/claim-check-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..04b17f084fde5e702cc032466e767cbf18d4a45d --- /dev/null +++ b/uncategorized/patterns/claim-check-workflow/README.md @@ -0,0 +1,19 @@ +# Claim Check Workflow + +This workflow models keeping large payloads external and only passing references. + +**Template ID:** `claim-check-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [claim, check, patterns] +**Source path:** `patterns/claim-check` +**Repo path:** `uncategorized/patterns/claim-check-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/claim-check-workflow/metadata.json b/uncategorized/patterns/claim-check-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7881cc0a1609125f7e0a6ba51126d6c75d595a0c --- /dev/null +++ b/uncategorized/patterns/claim-check-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "claim-check-workflow", + "workflow_id": "claim-check", + "title": "Claim Check Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "claim", + "check", + "patterns" + ], + "description": "This workflow models keeping large payloads external and only passing references.", + "source_path": "patterns/claim-check", + "repo_path": "uncategorized/patterns/claim-check-workflow" +} diff --git a/uncategorized/patterns/claim-check-workflow/workflow.fz b/uncategorized/patterns/claim-check-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e44269c3ddba8e3a6952236f1a92cfadfdf2153a --- /dev/null +++ b/uncategorized/patterns/claim-check-workflow/workflow.fz @@ -0,0 +1,18 @@ +user { # User + n1: circle label:"Start Claim Check" + n3: rectangle label:"Validate Claim Check conditions" + n5: rectangle label:"Record Claim Check outcome" + n7: circle label:"End Claim Check" + n1.handle(bottom) -> app.n2.handle(top) + n3.handle(bottom) -> app.n4.handle(top) [label="Processed"] + n5.handle(bottom) -> app.n6.handle(top) +} + +app { # App + n2: rectangle label:"Receive Claim Check event" + n4: rectangle label:"Execute Claim Check action" + n6: rectangle label:"Monitor Claim Check status" + n2.handle(right) -> user.n3.handle(left) + n4.handle(right) -> user.n5.handle(left) + n6.handle(right) -> user.n7.handle(left) [label="Success"] +} diff --git a/uncategorized/patterns/compensation-transaction-workflow/README.md b/uncategorized/patterns/compensation-transaction-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d495e2f50af632186265d04bd536cd2666634a62 --- /dev/null +++ b/uncategorized/patterns/compensation-transaction-workflow/README.md @@ -0,0 +1,19 @@ +# Compensation Transaction Workflow + +This workflow models rolling back work when a later step fails. + +**Template ID:** `compensation-transaction-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [compensation, transaction, patterns, decision, loop] +**Source path:** `patterns/compensation-transaction` +**Repo path:** `uncategorized/patterns/compensation-transaction-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/compensation-transaction-workflow/metadata.json b/uncategorized/patterns/compensation-transaction-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f2080014f90eba8f4dbe087801286584bc1800a1 --- /dev/null +++ b/uncategorized/patterns/compensation-transaction-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "compensation-transaction-workflow", + "workflow_id": "compensation-transaction", + "title": "Compensation Transaction Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "compensation", + "transaction", + "patterns", + "decision", + "loop" + ], + "description": "This workflow models rolling back work when a later step fails.", + "source_path": "patterns/compensation-transaction", + "repo_path": "uncategorized/patterns/compensation-transaction-workflow" +} diff --git a/uncategorized/patterns/compensation-transaction-workflow/workflow.fz b/uncategorized/patterns/compensation-transaction-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d6a06c88f3bd0355adfaae3225f433f033531f3e --- /dev/null +++ b/uncategorized/patterns/compensation-transaction-workflow/workflow.fz @@ -0,0 +1,19 @@ +user { # User + n1: circle label:"Start Compensation Transaction" + n2: diamond label:"Receive Compensation Transaction event" + n3: rectangle label:"Validate Compensation Transaction conditions" + n5: rectangle label:"Record Compensation Transaction outcome" + n7: circle label:"End Compensation Transaction" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> app.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(right) -> app.n6.handle(top) +} + +app { # App + n4: rectangle label:"Execute Compensation Transaction action" + n6: rectangle label:"Monitor Compensation Transaction status" + n6.handle(right) -> user.n7.handle(bottom) + n4.handle(right) -> user.n5.handle(bottom) +} diff --git a/uncategorized/patterns/content-enricher-workflow/README.md b/uncategorized/patterns/content-enricher-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..62759507cc9ab9a336dbbbd8f3ab55a241780f49 --- /dev/null +++ b/uncategorized/patterns/content-enricher-workflow/README.md @@ -0,0 +1,19 @@ +# Content Enricher Workflow + +This workflow models adding extra data from other sources. + +**Template ID:** `content-enricher-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [content, enricher, patterns, decision] +**Source path:** `patterns/content-enricher` +**Repo path:** `uncategorized/patterns/content-enricher-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/content-enricher-workflow/metadata.json b/uncategorized/patterns/content-enricher-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..dc859d9e1cb87fb31775c98a3cb88b247f4081b3 --- /dev/null +++ b/uncategorized/patterns/content-enricher-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "content-enricher-workflow", + "workflow_id": "content-enricher", + "title": "Content Enricher Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "content", + "enricher", + "patterns", + "decision" + ], + "description": "This workflow models adding extra data from other sources.", + "source_path": "patterns/content-enricher", + "repo_path": "uncategorized/patterns/content-enricher-workflow" +} diff --git a/uncategorized/patterns/content-enricher-workflow/workflow.fz b/uncategorized/patterns/content-enricher-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..9821b544ff8dece9ec2e5f8d1da762619e2396ba --- /dev/null +++ b/uncategorized/patterns/content-enricher-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Content Enricher" + n2: diamond label:"Receive Content Enricher event" + n4: rectangle label:"Execute Content Enricher action" + n7: rectangle label:"Monitor Content Enricher status" + n10: circle label:"End Content Enricher" + n1.handle(right) -> n2.handle(left) + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] +} + +app { # App + n5: rectangle label:"Record Content Enricher outcome" + n8: rectangle label:"Monitor Content Enricher status" + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Content Enricher conditions" + n6: rectangle label:"Monitor Content Enricher status" + n9: rectangle label:"Monitor Content Enricher status" + n9.handle(right) -> user.n10.handle(bottom) + n6.handle(right) -> user.n7.handle(left) + n3.handle(left) -> app.n5.handle(left) +} diff --git a/uncategorized/patterns/cqrs-workflow/README.md b/uncategorized/patterns/cqrs-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d986fccd501464f303aab7e929783269558858bd --- /dev/null +++ b/uncategorized/patterns/cqrs-workflow/README.md @@ -0,0 +1,19 @@ +# Cqrs Workflow + +CQRS (Command Query Responsibility Segregation) pattern with separate command and query paths, domain event publishing, read model synchronization, and DTO transformation. + +**Template ID:** `cqrs-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 19 +**Lanes:** 4 +**Tags:** [cqrs, command-query-separation, event-sourcing, read-model, write-model, domain-events, eventual-consistency] +**Source path:** `patterns/cqrs` +**Repo path:** `uncategorized/patterns/cqrs-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/cqrs-workflow/metadata.json b/uncategorized/patterns/cqrs-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..51f3c61dc89fa330dc9e12de1fa5950734212e5b --- /dev/null +++ b/uncategorized/patterns/cqrs-workflow/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "cqrs-workflow", + "workflow_id": "cqrs", + "title": "Cqrs Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 19, + "num_lanes": 4, + "tags": [ + "cqrs", + "command-query-separation", + "event-sourcing", + "read-model", + "write-model", + "domain-events", + "eventual-consistency" + ], + "description": "CQRS (Command Query Responsibility Segregation) pattern with separate command and query paths, domain event publishing, read model synchronization, and DTO transformation.", + "source_path": "patterns/cqrs", + "repo_path": "uncategorized/patterns/cqrs-workflow" +} diff --git a/uncategorized/patterns/cqrs-workflow/workflow.fz b/uncategorized/patterns/cqrs-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..84045e9b5dc72b83d966ffca0ad5070908565ddd --- /dev/null +++ b/uncategorized/patterns/cqrs-workflow/workflow.fz @@ -0,0 +1,48 @@ +Client { # Client Application +n1: circle label:"Start" +n2: rectangle label:"User initiates action" +n3: diamond label:"Read or write?" +n4: rectangle label:"Send command" +n5: rectangle label:"Send query" +n6: rectangle label:"Receive response" +n7: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) [label="Write"] +n3.handle(bottom) -> n5.handle(top) [label="Read"] +n4.handle(bottom) -> CommandSide.n8.handle(top) [label="Command"] +n5.handle(bottom) -> QuerySide.n16.handle(top) [label="Query"] +n6.handle(right) -> n7.handle(left) +} +CommandSide { # Command Side +n8: rectangle label:"Validate command" +n9: diamond label:"Command valid?" +n10: rectangle label:"Execute domain logic" +n11: rectangle label:"Persist to write store" +n12: rectangle label:"Publish domain event" +n13: rectangle label:"Return validation error" +n8.handle(right) -> n9.handle(left) +n9.handle(right) -> n10.handle(left) [label="Yes"] +n9.handle(bottom) -> n13.handle(top) [label="No"] +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) +n12.handle(bottom) -> EventHandler.n14.handle(top) [label="Event"] +n12.handle(top) -> Client.n6.handle(bottom) [label="Success"] +n13.handle(top) -> Client.n6.handle(bottom) [label="Error"] +} +EventHandler { # Event Handler +n14: rectangle label:"Receive domain event" +n15: rectangle label:"Update read model" +n14.handle(right) -> n15.handle(left) +n15.handle(top) -> QuerySide.n16.handle(bottom) [label="Sync"] +} +QuerySide { # Query Side +n16: rectangle label:"Parse query parameters" +n17: rectangle label:"Query read store" +n18: rectangle label:"Transform to DTO" +n19: rectangle label:"Return results" +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> Client.n6.handle(bottom) [label="Data"] +} diff --git a/uncategorized/patterns/crud-user-browser-server-workflow/README.md b/uncategorized/patterns/crud-user-browser-server-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..51d2ce8f12878f69f560ef04e85da7d7288ff595 --- /dev/null +++ b/uncategorized/patterns/crud-user-browser-server-workflow/README.md @@ -0,0 +1,19 @@ +# Crud User Browser Server Workflow + +This workflow models user creates, reads, updates, and deletes data through a browser and server. + +**Template ID:** `crud-user-browser-server-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [crud, user, browser, server, patterns] +**Source path:** `patterns/crud-user-browser-server` +**Repo path:** `uncategorized/patterns/crud-user-browser-server-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/crud-user-browser-server-workflow/metadata.json b/uncategorized/patterns/crud-user-browser-server-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..a34049b3a89fbd81928559b881ca93065d7f4947 --- /dev/null +++ b/uncategorized/patterns/crud-user-browser-server-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "crud-user-browser-server-workflow", + "workflow_id": "crud-user-browser-server", + "title": "Crud User Browser Server Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "crud", + "user", + "browser", + "server", + "patterns" + ], + "description": "This workflow models user creates, reads, updates, and deletes data through a browser and server.", + "source_path": "patterns/crud-user-browser-server", + "repo_path": "uncategorized/patterns/crud-user-browser-server-workflow" +} diff --git a/uncategorized/patterns/crud-user-browser-server-workflow/workflow.fz b/uncategorized/patterns/crud-user-browser-server-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..513ba5300d5159f63e467b8f6237e7b0ddd0727c --- /dev/null +++ b/uncategorized/patterns/crud-user-browser-server-workflow/workflow.fz @@ -0,0 +1,19 @@ +user { # User + n1: circle label:"Start Crud User Browser Server" + n2: diamond label:"Receive Crud User Browser Server event" + n3: rectangle label:"Validate Crud User Browser Server conditions" + n5: rectangle label:"Record Crud User Browser Server outcome" + n7: circle label:"End Crud User Browser Server" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> app.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> app.n6.handle(top) +} + +app { # App + n4: rectangle label:"Execute Crud User Browser Server action" + n6: rectangle label:"Monitor Crud User Browser Server status" + n6.handle(right) -> user.n7.handle(left) + n4.handle(right) -> user.n5.handle(top) +} diff --git a/uncategorized/patterns/dead-letter-queue-workflow/README.md b/uncategorized/patterns/dead-letter-queue-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5502d76e822b0f900dc434b0be35741e5a415fea --- /dev/null +++ b/uncategorized/patterns/dead-letter-queue-workflow/README.md @@ -0,0 +1,19 @@ +# Dead Letter Queue Workflow + +Dead letter queue pattern for handling failed messages with retry exhaustion detection, DLQ routing, manual inspection, and reprocessing capability. + +**Template ID:** `dead-letter-queue-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [dead-letter-queue, dlq, message-retry, poison-message, error-handling, message-queue] +**Source path:** `patterns/dead-letter-queue` +**Repo path:** `uncategorized/patterns/dead-letter-queue-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/dead-letter-queue-workflow/metadata.json b/uncategorized/patterns/dead-letter-queue-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..30a95d65d1aa84fbbb662a3a0d088b6710e648b4 --- /dev/null +++ b/uncategorized/patterns/dead-letter-queue-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "dead-letter-queue-workflow", + "workflow_id": "dead-letter-queue", + "title": "Dead Letter Queue Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "dead-letter-queue", + "dlq", + "message-retry", + "poison-message", + "error-handling", + "message-queue" + ], + "description": "Dead letter queue pattern for handling failed messages with retry exhaustion detection, DLQ routing, manual inspection, and reprocessing capability.", + "source_path": "patterns/dead-letter-queue", + "repo_path": "uncategorized/patterns/dead-letter-queue-workflow" +} diff --git a/uncategorized/patterns/dead-letter-queue-workflow/workflow.fz b/uncategorized/patterns/dead-letter-queue-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..eaf87f9a19dd9077459589ceda6f181094e58a2d --- /dev/null +++ b/uncategorized/patterns/dead-letter-queue-workflow/workflow.fz @@ -0,0 +1,44 @@ +MainQueue { # Main Queue +n1: circle label:"Start" +n2: rectangle label:"Receive message" +n3: rectangle label:"Attempt processing" +n4: diamond label:"Processing successful?" +n5: rectangle label:"Acknowledge message" +n6: rectangle label:"Increment retry count" +n7: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(right) -> n4.handle(left) +n4.handle(right) -> n5.handle(left) [label="Yes"] +n4.handle(bottom) -> n6.handle(top) [label="No"] +n5.handle(right) -> n7.handle(left) +n6.handle(bottom) -> RetryLogic.n8.handle(top) [label="Check retries"] +} +RetryLogic { # Retry Logic +n8: diamond label:"Max retries exceeded?" +n9: rectangle label:"Wait with backoff" +n10: rectangle label:"Requeue message" +n11: rectangle label:"Move to DLQ" +n8.handle(right) -> n9.handle(left) [label="No"] +n8.handle(bottom) -> n11.handle(top) [label="Yes"] +n9.handle(right) -> n10.handle(left) +n10.handle(top) -> MainQueue.n3.handle(bottom) [label="Retry"] +n11.handle(bottom) -> DeadLetterQueue.n12.handle(top) [label="Failed"] +} +DeadLetterQueue { # Dead Letter Queue +n12: rectangle label:"Store failed message" +n13: rectangle label:"Log failure details" +n14: rectangle label:"Send alert notification" +n15: rectangle label:"Await manual review" +n16: diamond label:"Reprocess or discard?" +n17: rectangle label:"Move back to main queue" +n18: rectangle label:"Archive and delete" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) [label="Reprocess"] +n16.handle(bottom) -> n18.handle(top) [label="Discard"] +n17.handle(top) -> MainQueue.n2.handle(bottom) [label="Retry"] +n18.handle(top) -> MainQueue.n7.handle(bottom) [label="Discarded"] +} diff --git a/uncategorized/patterns/decision-diamond-workflow/README.md b/uncategorized/patterns/decision-diamond-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b8dc736d7b75f0e840e30b2ab77391cbb3c8684f --- /dev/null +++ b/uncategorized/patterns/decision-diamond-workflow/README.md @@ -0,0 +1,19 @@ +# Decision Diamond Workflow + +This workflow models an if or then style branch for approval or rejection. + +**Template ID:** `decision-diamond-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [decision, diamond, patterns] +**Source path:** `patterns/decision-diamond` +**Repo path:** `uncategorized/patterns/decision-diamond-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/decision-diamond-workflow/metadata.json b/uncategorized/patterns/decision-diamond-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8cbb0ecd2fbf76a624dba433b584cb5ffa93ab02 --- /dev/null +++ b/uncategorized/patterns/decision-diamond-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "decision-diamond-workflow", + "workflow_id": "decision-diamond", + "title": "Decision Diamond Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "decision", + "diamond", + "patterns" + ], + "description": "This workflow models an if or then style branch for approval or rejection.", + "source_path": "patterns/decision-diamond", + "repo_path": "uncategorized/patterns/decision-diamond-workflow" +} diff --git a/uncategorized/patterns/decision-diamond-workflow/workflow.fz b/uncategorized/patterns/decision-diamond-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b32cf21185e2822d7c6d464b47ffa4d4f4be805c --- /dev/null +++ b/uncategorized/patterns/decision-diamond-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Decision Diamond" + n2: diamond label:"Receive Decision Diamond event" + n4: rectangle label:"Execute Decision Diamond action" + n7: rectangle label:"Monitor Decision Diamond status" + n10: circle label:"End Decision Diamond" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +app { # App + n5: rectangle label:"Record Decision Diamond outcome" + n8: rectangle label:"Monitor Decision Diamond status" + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: diamond label:"Validate Decision Diamond conditions" + n6: rectangle label:"Monitor Decision Diamond status" + n9: rectangle label:"Monitor Decision Diamond status" + n9.handle(right) -> user.n10.handle(bottom) + n6.handle(right) -> user.n7.handle(left) + n3.handle(left) -> app.n5.handle(left) +} diff --git a/uncategorized/patterns/enricher-workflow/README.md b/uncategorized/patterns/enricher-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dc43c31b1d7576cd363b814df706f7215a530aa0 --- /dev/null +++ b/uncategorized/patterns/enricher-workflow/README.md @@ -0,0 +1,19 @@ +# Enricher Workflow + +This workflow models adding metadata to messages before passing them on. + +**Template ID:** `enricher-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [enricher, patterns] +**Source path:** `patterns/enricher` +**Repo path:** `uncategorized/patterns/enricher-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/enricher-workflow/metadata.json b/uncategorized/patterns/enricher-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..55f1146ab3158c1a1ce0b6e33bb116285f225f77 --- /dev/null +++ b/uncategorized/patterns/enricher-workflow/metadata.json @@ -0,0 +1,20 @@ +{ + "template_id": "enricher-workflow", + "workflow_id": "enricher", + "title": "Enricher Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "enricher", + "patterns" + ], + "description": "This workflow models adding metadata to messages before passing them on.", + "source_path": "patterns/enricher", + "repo_path": "uncategorized/patterns/enricher-workflow" +} diff --git a/uncategorized/patterns/enricher-workflow/workflow.fz b/uncategorized/patterns/enricher-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..dd0386f31e3e191d9a2a8eb0b46bc0bee6e98501 --- /dev/null +++ b/uncategorized/patterns/enricher-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Enricher" + n4: diamond label:"Execute Enricher action" + n7: rectangle label:"Monitor Enricher status" + n10: circle label:"End Enricher" + n1.handle(bottom) -> app.n2.handle(top) + n4.handle(bottom) -> app.n5.handle(top) + n4.handle(right) -> service.n3.handle(right) [label="Retry/Rejected"] + n7.handle(bottom) -> app.n8.handle(top) +} + +app { # App + n2: rectangle label:"Receive Enricher event" + n5: rectangle label:"Record Enricher outcome" + n8: rectangle label:"Monitor Enricher status" + n2.handle(bottom) -> service.n3.handle(top) + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Enricher conditions" + n6: rectangle label:"Monitor Enricher status" + n9: rectangle label:"Monitor Enricher status" + n9.handle(right) -> user.n10.handle(bottom) [label="Valid"] + n6.handle(right) -> user.n7.handle(left) [label="Success"] + n3.handle(bottom) -> user.n4.handle(left) [label="Processed"] +} diff --git a/uncategorized/patterns/error-retry-loop-workflow/README.md b/uncategorized/patterns/error-retry-loop-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..441c2138e08170dbfa26f1a5a1697d1e262f366e --- /dev/null +++ b/uncategorized/patterns/error-retry-loop-workflow/README.md @@ -0,0 +1,19 @@ +# Error Retry Loop Workflow + +This workflow models a failed operation that retries with backoff. + +**Template ID:** `error-retry-loop-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [error, retry, loop, patterns] +**Source path:** `patterns/error-retry-loop` +**Repo path:** `uncategorized/patterns/error-retry-loop-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/error-retry-loop-workflow/metadata.json b/uncategorized/patterns/error-retry-loop-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e289106db211b6e9540e5177876e679cd825e05e --- /dev/null +++ b/uncategorized/patterns/error-retry-loop-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "error-retry-loop-workflow", + "workflow_id": "error-retry-loop", + "title": "Error Retry Loop Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "error", + "retry", + "loop", + "patterns" + ], + "description": "This workflow models a failed operation that retries with backoff.", + "source_path": "patterns/error-retry-loop", + "repo_path": "uncategorized/patterns/error-retry-loop-workflow" +} diff --git a/uncategorized/patterns/error-retry-loop-workflow/workflow.fz b/uncategorized/patterns/error-retry-loop-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3d3d800ed01c672d5cbe50beaab59d5d6155b9f9 --- /dev/null +++ b/uncategorized/patterns/error-retry-loop-workflow/workflow.fz @@ -0,0 +1,17 @@ +Client { # Client + n1: circle label:"Start Transaction" + n2: rectangle label:"Attempt Payment" + n5: circle label:"Payment Success" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> Server.n3.handle(top) [label="Submit"] + n2.handle(right) -> n5.handle(left) [label="Authorized"] +} + +Server { # Server + n3: rectangle label:"Process Payment" + n4: diamond label:"Authorized?" + n3.handle(right) -> n4.handle(left) + n4.handle(right) -> Client.n5.handle(bottom) [label="Approved"] + n4.handle(top) -> Client.n2.handle(bottom) [label="Decline/Retry"] + loop [Retry until approved] n2 n3 n4 +} diff --git a/uncategorized/patterns/event-driven-workflow/README.md b/uncategorized/patterns/event-driven-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5bf1bf00a8c89eb99a4b5ef0812760cfc96ce960 --- /dev/null +++ b/uncategorized/patterns/event-driven-workflow/README.md @@ -0,0 +1,19 @@ +# Event Driven Workflow + +This workflow models reacting to incoming business events. + +**Template ID:** `event-driven-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [event, driven, patterns] +**Source path:** `patterns/event-driven` +**Repo path:** `uncategorized/patterns/event-driven-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/event-driven-workflow/metadata.json b/uncategorized/patterns/event-driven-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c64cd81153bdfd4d23c5778806565ea03731f8e6 --- /dev/null +++ b/uncategorized/patterns/event-driven-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "event-driven-workflow", + "workflow_id": "event-driven", + "title": "Event Driven Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "event", + "driven", + "patterns" + ], + "description": "This workflow models reacting to incoming business events.", + "source_path": "patterns/event-driven", + "repo_path": "uncategorized/patterns/event-driven-workflow" +} diff --git a/uncategorized/patterns/event-driven-workflow/workflow.fz b/uncategorized/patterns/event-driven-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..1f9ad96f8065109f5deadfc93acdf4b8e76db7a1 --- /dev/null +++ b/uncategorized/patterns/event-driven-workflow/workflow.fz @@ -0,0 +1,47 @@ +Producer { # Event Producer +n1: circle label:"Start" +n2: rectangle label:"User action occurs" +n3: rectangle label:"Create event payload" +n4: rectangle label:"Publish to message broker" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> MessageBroker.n6.handle(top) [label="Publish"] +n4.handle(right) -> n5.handle(left) +} +MessageBroker { # Message Broker +n6: rectangle label:"Receive event message" +n7: rectangle label:"Validate message schema" +n8: diamond label:"Valid schema?" +n9: rectangle label:"Route to topic partition" +n10: rectangle label:"Send to dead letter queue" +n11: rectangle label:"Acknowledge receipt" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(top) -> Producer.n5.handle(bottom) [label="DLQ"] +n11.handle(top) -> Producer.n4.handle(bottom) [label="ACK"] +n11.handle(bottom) -> Consumer.n12.handle(top) [label="Deliver"] +} +Consumer { # Event Consumer +n12: rectangle label:"Poll for new messages" +n13: rectangle label:"Deserialize event" +n14: diamond label:"Event type?" +n15: rectangle label:"Handle order created" +n16: rectangle label:"Handle payment received" +n17: rectangle label:"Handle user registered" +n18: rectangle label:"Process business logic" +n19: rectangle label:"Commit offset" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) [label="order.created"] +n14.handle(bottom) -> n16.handle(top) [label="payment.received"] +n14.handle(left) -> n17.handle(top) [label="user.registered"] +n15.handle(bottom) -> n18.handle(top) +n16.handle(bottom) -> n18.handle(top) +n17.handle(bottom) -> n18.handle(top) +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> Producer.n5.handle(bottom) [label="Complete"] +} diff --git a/uncategorized/patterns/feature-toggle-workflow/README.md b/uncategorized/patterns/feature-toggle-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d5f7a8e89c9705c9923281b15e5127ff40043951 --- /dev/null +++ b/uncategorized/patterns/feature-toggle-workflow/README.md @@ -0,0 +1,19 @@ +# Feature Toggle Workflow + +Feature toggle pattern with flag configuration, user targeting rules, percentage rollouts, and instant kill-switch capability for production features. + +**Template ID:** `feature-toggle-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [feature-toggle, feature-flags, dark-launch, a-b-testing, gradual-rollout, kill-switch] +**Source path:** `patterns/feature-toggle` +**Repo path:** `uncategorized/patterns/feature-toggle-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/feature-toggle-workflow/metadata.json b/uncategorized/patterns/feature-toggle-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..20c25f23ff5c7a5aac28f8a3fa42e9ebaaa43bc2 --- /dev/null +++ b/uncategorized/patterns/feature-toggle-workflow/metadata.json @@ -0,0 +1,24 @@ +{ + "template_id": "feature-toggle-workflow", + "workflow_id": "feature-toggle", + "title": "Feature Toggle Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "feature-toggle", + "feature-flags", + "dark-launch", + "a-b-testing", + "gradual-rollout", + "kill-switch" + ], + "description": "Feature toggle pattern with flag configuration, user targeting rules, percentage rollouts, and instant kill-switch capability for production features.", + "source_path": "patterns/feature-toggle", + "repo_path": "uncategorized/patterns/feature-toggle-workflow" +} diff --git a/uncategorized/patterns/feature-toggle-workflow/workflow.fz b/uncategorized/patterns/feature-toggle-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e29b9d247719a9976cab39c95f6a6db1bafa1f7f --- /dev/null +++ b/uncategorized/patterns/feature-toggle-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Feature Toggle" + n4: rectangle label:"Execute Feature Toggle action" + n7: rectangle label:"Monitor Feature Toggle status" + n10: circle label:"End Feature Toggle" + n1.handle(bottom) -> app.n2.handle(top) + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) +} + +app { # App + n2: rectangle label:"Receive Feature Toggle event" + n5: rectangle label:"Record Feature Toggle outcome" + n8: rectangle label:"Monitor Feature Toggle status" + n2.handle(bottom) -> service.n3.handle(top) + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Feature Toggle conditions" + n6: diamond label:"Monitor Feature Toggle status" + n9: rectangle label:"Monitor Feature Toggle status" + n9.handle(right) -> user.n10.handle(bottom) [label="Valid"] + n6.handle(left) -> app.n5.handle(left) [label="Retry/Rejected"] + n6.handle(right) -> user.n7.handle(left) [label="Success"] + n3.handle(right) -> user.n4.handle(left) [label="Processed"] +} diff --git a/uncategorized/patterns/filter-workflow/README.md b/uncategorized/patterns/filter-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d5f8455cc005d227e142e5639fbe0fb43367b59f --- /dev/null +++ b/uncategorized/patterns/filter-workflow/README.md @@ -0,0 +1,19 @@ +# Filter Workflow + +This workflow models removing items that do not meet criteria. + +**Template ID:** `filter-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [filter, patterns, decision, loop] +**Source path:** `patterns/filter` +**Repo path:** `uncategorized/patterns/filter-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/filter-workflow/metadata.json b/uncategorized/patterns/filter-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c97678d08c7b57cc0183311c258f4692fa1fbf4e --- /dev/null +++ b/uncategorized/patterns/filter-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "filter-workflow", + "workflow_id": "filter", + "title": "Filter Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "filter", + "patterns", + "decision", + "loop" + ], + "description": "This workflow models removing items that do not meet criteria.", + "source_path": "patterns/filter", + "repo_path": "uncategorized/patterns/filter-workflow" +} diff --git a/uncategorized/patterns/filter-workflow/workflow.fz b/uncategorized/patterns/filter-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..1d4aa29d5dc22022f6945918d5acad0218b1ad04 --- /dev/null +++ b/uncategorized/patterns/filter-workflow/workflow.fz @@ -0,0 +1,38 @@ +user { # User + n1: circle label:"Start Filter" + n2: diamond label:"Receive Filter event" + n5: rectangle label:"Record Filter outcome" + n9: rectangle label:"Monitor Filter status" + n13: circle label:"End Filter" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] + n2.handle(bottom) -> database.n4.handle(top) [label="No/Rejected"] + n5.handle(bottom) -> app.n6.handle(top) + n9.handle(bottom) -> app.n10.handle(top) +} + +app { # App + n6: rectangle label:"Monitor Filter status" + n10: rectangle label:"Monitor Filter status" + n6.handle(bottom) -> service.n7.handle(top) + n10.handle(bottom) -> service.n11.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Filter conditions" + n7: rectangle label:"Monitor Filter status" + n11: rectangle label:"Monitor Filter status" + n7.handle(bottom) -> database.n8.handle(top) + n11.handle(bottom) -> database.n12.handle(top) + n3.handle(right) -> user.n5.handle(top) +} + +database { # Database + n4: rectangle label:"Execute Filter action" + n8: rectangle label:"Monitor Filter status" + n12: rectangle label:"Monitor Filter status" + n12.handle(right) -> user.n13.handle(bottom) + n8.handle(right) -> user.n9.handle(left) + n4.handle(right) -> user.n5.handle(left) + loop [retry until success] n2 n5 n9 n6 n10 n3 n7 n11 n4 n8 n12 +} diff --git a/uncategorized/patterns/idempotent-consumer-workflow/README.md b/uncategorized/patterns/idempotent-consumer-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9debfc069eba01b4194433bc0cb50ba595cd59d7 --- /dev/null +++ b/uncategorized/patterns/idempotent-consumer-workflow/README.md @@ -0,0 +1,19 @@ +# Idempotent Consumer Workflow + +This workflow models processing each message safely only once. + +**Template ID:** `idempotent-consumer-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [idempotent, consumer, patterns] +**Source path:** `patterns/idempotent-consumer` +**Repo path:** `uncategorized/patterns/idempotent-consumer-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/idempotent-consumer-workflow/metadata.json b/uncategorized/patterns/idempotent-consumer-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ba650c75d1bd5a73044c810f20fa101be08460aa --- /dev/null +++ b/uncategorized/patterns/idempotent-consumer-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "idempotent-consumer-workflow", + "workflow_id": "idempotent-consumer", + "title": "Idempotent Consumer Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "idempotent", + "consumer", + "patterns" + ], + "description": "This workflow models processing each message safely only once.", + "source_path": "patterns/idempotent-consumer", + "repo_path": "uncategorized/patterns/idempotent-consumer-workflow" +} diff --git a/uncategorized/patterns/idempotent-consumer-workflow/workflow.fz b/uncategorized/patterns/idempotent-consumer-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..56471289c3ea782ed0abf9b84379a6ea47f1c189 --- /dev/null +++ b/uncategorized/patterns/idempotent-consumer-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Idempotent Consumer" + n4: rectangle label:"Execute Idempotent Consumer action" + n7: rectangle label:"Monitor Idempotent Consumer status" + n10: circle label:"End Idempotent Consumer" + n1.handle(bottom) -> app.n2.handle(top) [label="Success"] + n4.handle(bottom) -> app.n5.handle(top) [label="Valid"] + n7.handle(bottom) -> app.n8.handle(top) [label="Next"] +} + +app { # App + n2: rectangle label:"Receive Idempotent Consumer event" + n5: rectangle label:"Record Idempotent Consumer outcome" + n8: diamond label:"Monitor Idempotent Consumer status" + n2.handle(bottom) -> service.n3.handle(top) + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) + n8.handle(right) -> user.n7.handle(right) [label="Retry/Rejected"] +} + +service { # Service + n3: rectangle label:"Validate Idempotent Consumer conditions" + n6: rectangle label:"Monitor Idempotent Consumer status" + n9: rectangle label:"Monitor Idempotent Consumer status" + n9.handle(right) -> user.n10.handle(bottom) + n6.handle(right) -> user.n7.handle(left) + n3.handle(right) -> user.n4.handle(left) +} diff --git a/uncategorized/patterns/materialized-view-workflow/README.md b/uncategorized/patterns/materialized-view-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9f02b42089bc0c99b9b3756c8cc596f86091a719 --- /dev/null +++ b/uncategorized/patterns/materialized-view-workflow/README.md @@ -0,0 +1,19 @@ +# Materialized View Workflow + +This workflow models serving queries from a precomputed view. + +**Template ID:** `materialized-view-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [materialized, view, patterns, decision, loop] +**Source path:** `patterns/materialized-view` +**Repo path:** `uncategorized/patterns/materialized-view-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/materialized-view-workflow/metadata.json b/uncategorized/patterns/materialized-view-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..5cd765105d18bcb4540e52cc68c516a1b8fd8d2d --- /dev/null +++ b/uncategorized/patterns/materialized-view-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "materialized-view-workflow", + "workflow_id": "materialized-view", + "title": "Materialized View Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "materialized", + "view", + "patterns", + "decision", + "loop" + ], + "description": "This workflow models serving queries from a precomputed view.", + "source_path": "patterns/materialized-view", + "repo_path": "uncategorized/patterns/materialized-view-workflow" +} diff --git a/uncategorized/patterns/materialized-view-workflow/workflow.fz b/uncategorized/patterns/materialized-view-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..33d29c7545ecafd564cfca18134bd77d4fbd9cf9 --- /dev/null +++ b/uncategorized/patterns/materialized-view-workflow/workflow.fz @@ -0,0 +1,37 @@ +user { # User + n1: circle label:"Start Materialized View" + n2: diamond label:"Receive Materialized View event" + n5: rectangle label:"Record Materialized View outcome" + n9: rectangle label:"Monitor Materialized View status" + n13: circle label:"End Materialized View" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] + n5.handle(bottom) -> app.n6.handle(top) + n9.handle(bottom) -> app.n10.handle(top) + n2.handle(right) -> database.n4.handle(top) [label="No/Rejected"] +} + +app { # App + n6: rectangle label:"Monitor Materialized View status" + n10: rectangle label:"Monitor Materialized View status" + n6.handle(bottom) -> service.n7.handle(top) + n10.handle(bottom) -> service.n11.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Materialized View conditions" + n7: rectangle label:"Monitor Materialized View status" + n11: rectangle label:"Monitor Materialized View status" + n7.handle(bottom) -> database.n8.handle(top) + n11.handle(bottom) -> database.n12.handle(top) + n3.handle(right) -> user.n5.handle(top) +} + +database { # Database + n4: rectangle label:"Execute Materialized View action" + n8: rectangle label:"Monitor Materialized View status" + n12: rectangle label:"Monitor Materialized View status" + n12.handle(right) -> user.n13.handle(bottom) + n8.handle(right) -> user.n9.handle(left) + n4.handle(right) -> user.n5.handle(left) +} diff --git a/uncategorized/patterns/message-queue-workflow/README.md b/uncategorized/patterns/message-queue-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e9f2a5941159448ad510ad8ee7f07228e3f1b538 --- /dev/null +++ b/uncategorized/patterns/message-queue-workflow/README.md @@ -0,0 +1,19 @@ +# Message Queue Workflow + +This workflow models asynchronous processing of work via a queue. + +**Template ID:** `message-queue-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [message, queue, patterns, decision] +**Source path:** `patterns/message-queue` +**Repo path:** `uncategorized/patterns/message-queue-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/message-queue-workflow/metadata.json b/uncategorized/patterns/message-queue-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3f46f53ab9f14a2b5a86be4514e91b56878c7706 --- /dev/null +++ b/uncategorized/patterns/message-queue-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "message-queue-workflow", + "workflow_id": "message-queue", + "title": "Message Queue Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "message", + "queue", + "patterns", + "decision" + ], + "description": "This workflow models asynchronous processing of work via a queue.", + "source_path": "patterns/message-queue", + "repo_path": "uncategorized/patterns/message-queue-workflow" +} diff --git a/uncategorized/patterns/message-queue-workflow/workflow.fz b/uncategorized/patterns/message-queue-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..2478ffc2ff84bbc32e1787d6cd19a7c5fe2faeb9 --- /dev/null +++ b/uncategorized/patterns/message-queue-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Message Queue" + n2: diamond label:"Receive Message Queue event" + n4: rectangle label:"Execute Message Queue action" + n7: rectangle label:"Monitor Message Queue status" + n10: circle label:"End Message Queue" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +app { # App + n5: rectangle label:"Record Message Queue outcome" + n8: rectangle label:"Monitor Message Queue status" + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Message Queue conditions" + n6: rectangle label:"Monitor Message Queue status" + n9: rectangle label:"Monitor Message Queue status" + n9.handle(right) -> user.n10.handle(left) + n6.handle(right) -> user.n7.handle(left) + n3.handle(right) -> app.n5.handle(left) +} diff --git a/uncategorized/patterns/nested-decisions-workflow/README.md b/uncategorized/patterns/nested-decisions-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b589dc3adfc5a7d5c7a38325ac5a244429559419 --- /dev/null +++ b/uncategorized/patterns/nested-decisions-workflow/README.md @@ -0,0 +1,19 @@ +# Nested Decisions Workflow + +This workflow models multiple layers of decisions before completion. + +**Template ID:** `nested-decisions-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [nested, decisions, patterns, decision, loop] +**Source path:** `patterns/nested-decisions` +**Repo path:** `uncategorized/patterns/nested-decisions-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/nested-decisions-workflow/metadata.json b/uncategorized/patterns/nested-decisions-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..c66fe09db20e03df583f26010e76d1d291edf9ea --- /dev/null +++ b/uncategorized/patterns/nested-decisions-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "nested-decisions-workflow", + "workflow_id": "nested-decisions", + "title": "Nested Decisions Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "nested", + "decisions", + "patterns", + "decision", + "loop" + ], + "description": "This workflow models multiple layers of decisions before completion.", + "source_path": "patterns/nested-decisions", + "repo_path": "uncategorized/patterns/nested-decisions-workflow" +} diff --git a/uncategorized/patterns/nested-decisions-workflow/workflow.fz b/uncategorized/patterns/nested-decisions-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b3e58d65a34b94fcd5e124f6d56dbc6bcd6ce42b --- /dev/null +++ b/uncategorized/patterns/nested-decisions-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Nested Decisions" + n2: diamond label:"Receive Nested Decisions event" + n4: rectangle label:"Execute Nested Decisions action" + n7: rectangle label:"Monitor Nested Decisions status" + n10: circle label:"End Nested Decisions" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +app { # App + n5: rectangle label:"Record Nested Decisions outcome" + n8: rectangle label:"Monitor Nested Decisions status" + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: diamond label:"Validate Nested Decisions conditions" + n6: rectangle label:"Monitor Nested Decisions status" + n9: rectangle label:"Monitor Nested Decisions status" + n9.handle(right) -> user.n10.handle(bottom) + n6.handle(right) -> user.n7.handle(left) + n3.handle(right) -> app.n5.handle(left) +} diff --git a/uncategorized/patterns/normalizer-workflow/README.md b/uncategorized/patterns/normalizer-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b07493e95b0cc58f2e93894cd2653596362a9092 --- /dev/null +++ b/uncategorized/patterns/normalizer-workflow/README.md @@ -0,0 +1,19 @@ +# Normalizer Workflow + +This workflow models converting varied inputs to a standard format. + +**Template ID:** `normalizer-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [normalizer, patterns] +**Source path:** `patterns/normalizer` +**Repo path:** `uncategorized/patterns/normalizer-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/normalizer-workflow/metadata.json b/uncategorized/patterns/normalizer-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f25236bf5489f04498822c4af3ef43c7e13b1666 --- /dev/null +++ b/uncategorized/patterns/normalizer-workflow/metadata.json @@ -0,0 +1,20 @@ +{ + "template_id": "normalizer-workflow", + "workflow_id": "normalizer", + "title": "Normalizer Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "normalizer", + "patterns" + ], + "description": "This workflow models converting varied inputs to a standard format.", + "source_path": "patterns/normalizer", + "repo_path": "uncategorized/patterns/normalizer-workflow" +} diff --git a/uncategorized/patterns/normalizer-workflow/workflow.fz b/uncategorized/patterns/normalizer-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..58fb200b1c11cc1370489151624df59433094ed0 --- /dev/null +++ b/uncategorized/patterns/normalizer-workflow/workflow.fz @@ -0,0 +1,38 @@ +user { # User + n1: circle label:"Start Normalizer" + n5: rectangle label:"Record Normalizer outcome" + n9: rectangle label:"Monitor Normalizer status" + n13: circle label:"End Normalizer" + n1.handle(bottom) -> app.n2.handle(top) + n5.handle(bottom) -> app.n6.handle(top) [label="Done"] + n9.handle(bottom) -> app.n10.handle(top) +} + +app { # App + n2: rectangle label:"Receive Normalizer event" + n6: rectangle label:"Monitor Normalizer status" + n10: rectangle label:"Monitor Normalizer status" + n2.handle(bottom) -> service.n3.handle(top) [label="Next"] + n6.handle(bottom) -> service.n7.handle(top) + n10.handle(bottom) -> service.n11.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Normalizer conditions" + n7: rectangle label:"Monitor Normalizer status" + n11: rectangle label:"Monitor Normalizer status" + n3.handle(bottom) -> database.n4.handle(top) + n7.handle(bottom) -> database.n8.handle(top) + n11.handle(bottom) -> database.n12.handle(top) [label="Success"] +} + +database { # Database + n4: diamond label:"Execute Normalizer action" + n8: rectangle label:"Monitor Normalizer status" + n12: diamond label:"Monitor Normalizer status" + n4.handle(left) -> service.n3.handle(left) [label="Retry/Rejected"] + n4.handle(right) -> user.n5.handle(left) + n8.handle(right) -> user.n9.handle(left) [label="Processed"] + n12.handle(left) -> service.n11.handle(left) [label="Retry/Rejected"] + n12.handle(right) -> user.n13.handle(bottom) +} diff --git a/uncategorized/patterns/notification-pattern-workflow/README.md b/uncategorized/patterns/notification-pattern-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f0f4d77de5ca6d1dd56d61fc07cba4df1f598a9b --- /dev/null +++ b/uncategorized/patterns/notification-pattern-workflow/README.md @@ -0,0 +1,19 @@ +# Notification Pattern Workflow + +This workflow models sending alerts via multiple channels. + +**Template ID:** `notification-pattern-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [notification, pattern, patterns] +**Source path:** `patterns/notification-pattern` +**Repo path:** `uncategorized/patterns/notification-pattern-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/notification-pattern-workflow/metadata.json b/uncategorized/patterns/notification-pattern-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b6258c324a9f902a30370deaa2d8396acb4ab158 --- /dev/null +++ b/uncategorized/patterns/notification-pattern-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "notification-pattern-workflow", + "workflow_id": "notification-pattern", + "title": "Notification Pattern Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "notification", + "pattern", + "patterns" + ], + "description": "This workflow models sending alerts via multiple channels.", + "source_path": "patterns/notification-pattern", + "repo_path": "uncategorized/patterns/notification-pattern-workflow" +} diff --git a/uncategorized/patterns/notification-pattern-workflow/workflow.fz b/uncategorized/patterns/notification-pattern-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..b4fd18e041a9cdaf9a3667aefa905f34d873b920 --- /dev/null +++ b/uncategorized/patterns/notification-pattern-workflow/workflow.fz @@ -0,0 +1,18 @@ +user { # User + n1: circle label:"Start Notification Pattern" + n3: rectangle label:"Validate Notification Pattern conditions" + n5: rectangle label:"Record Notification Pattern outcome" + n7: circle label:"End Notification Pattern" + n1.handle(bottom) -> app.n2.handle(top) + n3.handle(bottom) -> app.n4.handle(top) + n5.handle(bottom) -> app.n6.handle(top) [label="Done"] +} + +app { # App + n2: rectangle label:"Receive Notification Pattern event" + n4: rectangle label:"Execute Notification Pattern action" + n6: rectangle label:"Monitor Notification Pattern status" + n2.handle(right) -> user.n3.handle(left) [label="Next"] + n4.handle(right) -> user.n5.handle(left) + n6.handle(right) -> user.n7.handle(left) +} diff --git a/uncategorized/patterns/parallel-execution-workflow/README.md b/uncategorized/patterns/parallel-execution-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..29221504620fec77f5001d93ba2bbc6ae782252a --- /dev/null +++ b/uncategorized/patterns/parallel-execution-workflow/README.md @@ -0,0 +1,19 @@ +# Parallel Execution Workflow + +This workflow models multiple tasks that run at the same time. + +**Template ID:** `parallel-execution-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [parallel, execution, patterns, loop] +**Source path:** `patterns/parallel-execution` +**Repo path:** `uncategorized/patterns/parallel-execution-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/parallel-execution-workflow/metadata.json b/uncategorized/patterns/parallel-execution-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9a7a24c2e4c085d8b5358b97f73e0acc7e1fcecc --- /dev/null +++ b/uncategorized/patterns/parallel-execution-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "parallel-execution-workflow", + "workflow_id": "parallel-execution", + "title": "Parallel Execution Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "parallel", + "execution", + "patterns", + "loop" + ], + "description": "This workflow models multiple tasks that run at the same time.", + "source_path": "patterns/parallel-execution", + "repo_path": "uncategorized/patterns/parallel-execution-workflow" +} diff --git a/uncategorized/patterns/parallel-execution-workflow/workflow.fz b/uncategorized/patterns/parallel-execution-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6751541b3abc983c2dc594ccf52041012e4846da --- /dev/null +++ b/uncategorized/patterns/parallel-execution-workflow/workflow.fz @@ -0,0 +1,46 @@ +user { # User + n1: circle label:"Start Parallel Execution" + n5: rectangle label:"Record Parallel Execution outcome" + n9: diamond label:"Monitor Parallel Execution status" + n13: circle label:"End Parallel Execution" + n1.handle(bottom) -> app.n2.handle(top) + n1.handle(bottom) -> service.n3.handle(top) + n1.handle(bottom) -> database.n4.handle(top) + n1.handle(right) -> n5.handle(left) + n1.handle(bottom) -> app.n6.handle(top) + n1.handle(bottom) -> service.n7.handle(top) + n1.handle(bottom) -> database.n8.handle(top) + n1.handle(bottom) -> app.n10.handle(top) + n1.handle(bottom) -> service.n11.handle(top) + n1.handle(bottom) -> database.n12.handle(top) + n5.handle(right) -> n13.handle(left) + n9.handle(right) -> n13.handle(left) + n1.handle(top) -> n9.handle(top) +} + +app { # App + n2: rectangle label:"Receive Parallel Execution event" + n6: rectangle label:"Monitor Parallel Execution status" + n10: rectangle label:"Monitor Parallel Execution status" + n10.handle(right) -> user.n13.handle(bottom) + n6.handle(right) -> user.n13.handle(bottom) + n2.handle(right) -> user.n13.handle(bottom) +} + +service { # Service + n3: rectangle label:"Validate Parallel Execution conditions" + n7: rectangle label:"Monitor Parallel Execution status" + n11: rectangle label:"Monitor Parallel Execution status" + n3.handle(right) -> user.n13.handle(bottom) + n7.handle(right) -> user.n13.handle(bottom) + n11.handle(right) -> user.n13.handle(bottom) +} + +database { # Database + n4: rectangle label:"Execute Parallel Execution action" + n8: rectangle label:"Monitor Parallel Execution status" + n12: rectangle label:"Monitor Parallel Execution status" + n12.handle(right) -> user.n13.handle(bottom) + n8.handle(right) -> user.n13.handle(bottom) + n4.handle(right) -> user.n13.handle(bottom) +} diff --git a/uncategorized/patterns/polling-pattern-workflow/README.md b/uncategorized/patterns/polling-pattern-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..04dd355b73684a3b642d5fb5c24280bbf447b5d5 --- /dev/null +++ b/uncategorized/patterns/polling-pattern-workflow/README.md @@ -0,0 +1,19 @@ +# Polling Pattern Workflow + +This workflow models periodically checking status until work is done. + +**Template ID:** `polling-pattern-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [polling, pattern, patterns, loop] +**Source path:** `patterns/polling-pattern` +**Repo path:** `uncategorized/patterns/polling-pattern-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/polling-pattern-workflow/metadata.json b/uncategorized/patterns/polling-pattern-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bd4c7dfdc859f1f83760193b8d7c7b991d290472 --- /dev/null +++ b/uncategorized/patterns/polling-pattern-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "polling-pattern-workflow", + "workflow_id": "polling-pattern", + "title": "Polling Pattern Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "polling", + "pattern", + "patterns", + "loop" + ], + "description": "This workflow models periodically checking status until work is done.", + "source_path": "patterns/polling-pattern", + "repo_path": "uncategorized/patterns/polling-pattern-workflow" +} diff --git a/uncategorized/patterns/polling-pattern-workflow/workflow.fz b/uncategorized/patterns/polling-pattern-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..56ddc50ce3f9df625eb7e5beb3221e4628e0a3a7 --- /dev/null +++ b/uncategorized/patterns/polling-pattern-workflow/workflow.fz @@ -0,0 +1,38 @@ +user { # User + n1: circle label:"Start Polling Pattern" + n5: rectangle label:"Record Polling Pattern outcome" + n9: rectangle label:"Monitor Polling Pattern status" + n13: circle label:"End Polling Pattern" + n1.handle(bottom) -> app.n2.handle(top) + n5.handle(bottom) -> app.n6.handle(top) [label="Done"] + n9.handle(bottom) -> app.n10.handle(top) +} + +app { # App + n2: rectangle label:"Receive Polling Pattern event" + n6: rectangle label:"Monitor Polling Pattern status" + n10: rectangle label:"Monitor Polling Pattern status" + n2.handle(bottom) -> service.n3.handle(top) [label="Next"] + n6.handle(bottom) -> service.n7.handle(top) + n10.handle(bottom) -> service.n11.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Polling Pattern conditions" + n7: rectangle label:"Monitor Polling Pattern status" + n11: rectangle label:"Monitor Polling Pattern status" + n3.handle(bottom) -> database.n4.handle(top) + n7.handle(bottom) -> database.n8.handle(top) + n11.handle(bottom) -> database.n12.handle(top) [label="Success"] +} + +database { # Database + n4: diamond label:"Execute Polling Pattern action" + n8: rectangle label:"Monitor Polling Pattern status" + n12: diamond label:"Monitor Polling Pattern status" + n12.handle(left) -> service.n11.handle(left) [label="Retry/Rejected"] + n12.handle(right) -> user.n13.handle(left) + n8.handle(right) -> user.n9.handle(left) [label="Processed"] + n4.handle(left) -> service.n3.handle(left) [label="Retry/Rejected"] + n4.handle(right) -> user.n5.handle(left) +} diff --git a/uncategorized/patterns/process-manager-workflow/README.md b/uncategorized/patterns/process-manager-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9d428304616e61c05803d01e105576fb4aca0dc2 --- /dev/null +++ b/uncategorized/patterns/process-manager-workflow/README.md @@ -0,0 +1,19 @@ +# Process Manager Workflow + +This workflow models orchestrating multiple services to complete a process. + +**Template ID:** `process-manager-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [process, manager, patterns] +**Source path:** `patterns/process-manager` +**Repo path:** `uncategorized/patterns/process-manager-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/process-manager-workflow/metadata.json b/uncategorized/patterns/process-manager-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f262c5432b671af3fd34c54bbcf83dde4966ea33 --- /dev/null +++ b/uncategorized/patterns/process-manager-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "process-manager-workflow", + "workflow_id": "process-manager", + "title": "Process Manager Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "process", + "manager", + "patterns" + ], + "description": "This workflow models orchestrating multiple services to complete a process.", + "source_path": "patterns/process-manager", + "repo_path": "uncategorized/patterns/process-manager-workflow" +} diff --git a/uncategorized/patterns/process-manager-workflow/workflow.fz b/uncategorized/patterns/process-manager-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..d2cbc8e4efe2c826659dbfb64e5a7a011075ee42 --- /dev/null +++ b/uncategorized/patterns/process-manager-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Process Manager" + n4: rectangle label:"Execute Process Manager action" + n7: rectangle label:"Monitor Process Manager status" + n10: circle label:"End Process Manager" + n1.handle(bottom) -> app.n2.handle(top) + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) +} + +app { # App + n2: rectangle label:"Receive Process Manager event" + n5: rectangle label:"Record Process Manager outcome" + n8: rectangle label:"Monitor Process Manager status" + n2.handle(bottom) -> service.n3.handle(top) + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Process Manager conditions" + n6: rectangle label:"Monitor Process Manager status" + n9: diamond label:"Monitor Process Manager status" + n3.handle(right) -> user.n4.handle(left) [label="Processed"] + n6.handle(right) -> user.n7.handle(left) [label="Success"] + n9.handle(left) -> app.n8.handle(left) [label="Retry/Rejected"] + n9.handle(right) -> user.n10.handle(bottom) [label="Valide"] +} diff --git a/uncategorized/patterns/pub-sub-workflow/README.md b/uncategorized/patterns/pub-sub-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..acb887e8a3b1563d05e8d9541dfcdcce384b8c8e --- /dev/null +++ b/uncategorized/patterns/pub-sub-workflow/README.md @@ -0,0 +1,19 @@ +# Pub Sub Workflow + +This workflow models one publisher notifying many subscribers of events. + +**Template ID:** `pub-sub-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [pub, sub, patterns] +**Source path:** `patterns/pub-sub` +**Repo path:** `uncategorized/patterns/pub-sub-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/pub-sub-workflow/metadata.json b/uncategorized/patterns/pub-sub-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e4c4798fbd6b33609991b9501851c406ebeedc0c --- /dev/null +++ b/uncategorized/patterns/pub-sub-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "pub-sub-workflow", + "workflow_id": "pub-sub", + "title": "Pub Sub Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "pub", + "sub", + "patterns" + ], + "description": "This workflow models one publisher notifying many subscribers of events.", + "source_path": "patterns/pub-sub", + "repo_path": "uncategorized/patterns/pub-sub-workflow" +} diff --git a/uncategorized/patterns/pub-sub-workflow/workflow.fz b/uncategorized/patterns/pub-sub-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..fb66589a6f217b94a61a718ac393968e12b2ba51 --- /dev/null +++ b/uncategorized/patterns/pub-sub-workflow/workflow.fz @@ -0,0 +1,44 @@ +Publisher { # Publisher +n1: circle label:"Start" +n2: rectangle label:"Create message payload" +n3: rectangle label:"Serialize to JSON" +n4: rectangle label:"Publish to topic" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> MessageBroker.n6.handle(top) [label="Publish"] +n4.handle(right) -> n5.handle(left) +} +MessageBroker { # Message Broker +n6: rectangle label:"Receive message" +n7: rectangle label:"Validate message schema" +n8: diamond label:"Topic exists?" +n9: rectangle label:"Store in topic partition" +n10: rectangle label:"Create topic" +n11: rectangle label:"Notify subscribers" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="Yes"] +n8.handle(bottom) -> n10.handle(top) [label="No"] +n9.handle(right) -> n11.handle(left) +n10.handle(right) -> n9.handle(top) +n11.handle(bottom) -> Subscriber.n12.handle(top) [label="Deliver"] +n11.handle(top) -> Publisher.n4.handle(bottom) [label="ACK"] +} +Subscriber { # Subscriber +n12: rectangle label:"Receive notification" +n13: rectangle label:"Fetch message from topic" +n14: rectangle label:"Deserialize payload" +n15: diamond label:"Processing successful?" +n16: rectangle label:"Acknowledge message" +n17: rectangle label:"Negative acknowledge" +n18: rectangle label:"Update consumer offset" +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(right) -> n18.handle(left) +n17.handle(top) -> n13.handle(bottom) [label="Retry"] +n18.handle(top) -> Publisher.n5.handle(bottom) [label="Complete"] +} diff --git a/uncategorized/patterns/rate-limiter-workflow/README.md b/uncategorized/patterns/rate-limiter-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..abc0b2d51188c73df8c9b7a2d16eaeb8b729e630 --- /dev/null +++ b/uncategorized/patterns/rate-limiter-workflow/README.md @@ -0,0 +1,19 @@ +# Rate Limiter Workflow + +This workflow models preventing too many requests from being processed. + +**Template ID:** `rate-limiter-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [rate, limiter, patterns] +**Source path:** `patterns/rate-limiter` +**Repo path:** `uncategorized/patterns/rate-limiter-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/rate-limiter-workflow/metadata.json b/uncategorized/patterns/rate-limiter-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d20388475b428406de27040e9998e76301e7bded --- /dev/null +++ b/uncategorized/patterns/rate-limiter-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "rate-limiter-workflow", + "workflow_id": "rate-limiter", + "title": "Rate Limiter Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "rate", + "limiter", + "patterns" + ], + "description": "This workflow models preventing too many requests from being processed.", + "source_path": "patterns/rate-limiter", + "repo_path": "uncategorized/patterns/rate-limiter-workflow" +} diff --git a/uncategorized/patterns/rate-limiter-workflow/workflow.fz b/uncategorized/patterns/rate-limiter-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..274861742f9d561533c52f64de40ce40ea3df1e5 --- /dev/null +++ b/uncategorized/patterns/rate-limiter-workflow/workflow.fz @@ -0,0 +1,44 @@ +Client { # Client +n1: circle label:"Start" +n2: rectangle label:"Send API request" +n3: rectangle label:"Receive response" +n4: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> RateLimiter.n5.handle(top) [label="Request"] +n3.handle(right) -> n4.handle(left) +} +RateLimiter { # Rate Limiter +n5: rectangle label:"Extract client identifier" +n6: rectangle label:"Get current window count" +n7: diamond label:"Within rate limit?" +n8: rectangle label:"Increment request count" +n9: rectangle label:"Return 429 Too Many Requests" +n10: diamond label:"Algorithm type?" +n11: rectangle label:"Token bucket check" +n12: rectangle label:"Sliding window check" +n5.handle(right) -> n6.handle(left) +n6.handle(right) -> n10.handle(left) +n10.handle(right) -> n11.handle(left) [label="Token bucket"] +n10.handle(bottom) -> n12.handle(top) [label="Sliding window"] +n11.handle(right) -> n7.handle(left) +n12.handle(right) -> n7.handle(top) +n7.handle(right) -> n8.handle(left) [label="Yes"] +n7.handle(bottom) -> n9.handle(top) [label="No"] +n8.handle(bottom) -> Backend.n13.handle(top) [label="Allow"] +n9.handle(top) -> Client.n3.handle(bottom) [label="Rejected"] +} +Backend { # Backend Service +n13: rectangle label:"Process request" +n14: rectangle label:"Execute business logic" +n15: diamond label:"Request successful?" +n16: rectangle label:"Return 200 OK" +n17: rectangle label:"Return error response" +n18: rectangle label:"Add rate limit headers" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(right) -> n18.handle(left) +n17.handle(right) -> n18.handle(top) +n18.handle(top) -> Client.n3.handle(bottom) [label="Response"] +} diff --git a/uncategorized/patterns/request-reply-workflow/README.md b/uncategorized/patterns/request-reply-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9362a17728e94563bca89c988f9d0f441b6e244b --- /dev/null +++ b/uncategorized/patterns/request-reply-workflow/README.md @@ -0,0 +1,19 @@ +# Request Reply Workflow + +This workflow models a synchronous request that waits for a reply. + +**Template ID:** `request-reply-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [request, reply, patterns] +**Source path:** `patterns/request-reply` +**Repo path:** `uncategorized/patterns/request-reply-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/request-reply-workflow/metadata.json b/uncategorized/patterns/request-reply-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..5c60061ed32a9998be61ccf5dc89ab4ea3c470b2 --- /dev/null +++ b/uncategorized/patterns/request-reply-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "request-reply-workflow", + "workflow_id": "request-reply", + "title": "Request Reply Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "request", + "reply", + "patterns" + ], + "description": "This workflow models a synchronous request that waits for a reply.", + "source_path": "patterns/request-reply", + "repo_path": "uncategorized/patterns/request-reply-workflow" +} diff --git a/uncategorized/patterns/request-reply-workflow/workflow.fz b/uncategorized/patterns/request-reply-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..43d6e65692754864581986a7b3b4a87f992deaee --- /dev/null +++ b/uncategorized/patterns/request-reply-workflow/workflow.fz @@ -0,0 +1,19 @@ +user { # User + n1: circle label:"Start Request Reply" + n3: rectangle label:"Validate Request Reply conditions" + n5: rectangle label:"Record Request Reply outcome" + n7: circle label:"End Request Reply" + n1.handle(bottom) -> app.n2.handle(top) [label="Success"] + n3.handle(bottom) -> app.n4.handle(top) + n5.handle(bottom) -> app.n6.handle(top) +} + +app { # App + n2: rectangle label:"Receive Request Reply event" + n4: rectangle label:"Execute Request Reply action" + n6: diamond label:"Monitor Request Reply status" + n2.handle(right) -> user.n3.handle(left) + n4.handle(right) -> user.n5.handle(left) [label="Valid"] + n6.handle(left) -> user.n5.handle(left) [label="Retry/Rejected"] + n6.handle(right) -> user.n7.handle(bottom) +} diff --git a/uncategorized/patterns/retry-with-backoff-workflow/README.md b/uncategorized/patterns/retry-with-backoff-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0eac6ab7cc5b8dac259d256ec69e9f6570a99da9 --- /dev/null +++ b/uncategorized/patterns/retry-with-backoff-workflow/README.md @@ -0,0 +1,19 @@ +# Retry With Backoff Workflow + +Exponential backoff retry pattern for API calls with configurable retry limits, delay calculation, retryable error detection, and graceful degradation on permanent failures. + +**Template ID:** `retry-with-backoff-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 20 +**Lanes:** 3 +**Tags:** [retry-pattern, exponential-backoff, fault-tolerance, api-resilience, transient-errors, http-retry, jitter] +**Source path:** `patterns/retry-with-backoff` +**Repo path:** `uncategorized/patterns/retry-with-backoff-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/retry-with-backoff-workflow/metadata.json b/uncategorized/patterns/retry-with-backoff-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..8a0bade706e17b38bb5cba3d36559b8ca1a907bd --- /dev/null +++ b/uncategorized/patterns/retry-with-backoff-workflow/metadata.json @@ -0,0 +1,25 @@ +{ + "template_id": "retry-with-backoff-workflow", + "workflow_id": "retry-with-backoff", + "title": "Retry With Backoff Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 20, + "num_lanes": 3, + "tags": [ + "retry-pattern", + "exponential-backoff", + "fault-tolerance", + "api-resilience", + "transient-errors", + "http-retry", + "jitter" + ], + "description": "Exponential backoff retry pattern for API calls with configurable retry limits, delay calculation, retryable error detection, and graceful degradation on permanent failures.", + "source_path": "patterns/retry-with-backoff", + "repo_path": "uncategorized/patterns/retry-with-backoff-workflow" +} diff --git a/uncategorized/patterns/retry-with-backoff-workflow/workflow.fz b/uncategorized/patterns/retry-with-backoff-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..5a0fdc1f71141c0f0d871599f39cfffd7b952569 --- /dev/null +++ b/uncategorized/patterns/retry-with-backoff-workflow/workflow.fz @@ -0,0 +1,50 @@ +Client { # Client +n1: circle label:"Start" +n2: rectangle label:"Prepare API request" +n3: rectangle label:"Process successful response" +n4: rectangle label:"Handle permanent failure" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(bottom) -> RetryHandler.n6.handle(top) [label="Send request"] +n3.handle(right) -> n5.handle(left) +n4.handle(right) -> n5.handle(left) +} +RetryHandler { # Retry Handler +n6: rectangle label:"Initialize retry state" +n7: rectangle label:"Execute HTTP request" +n8: diamond label:"Response status?" +n9: rectangle label:"Return success" +n10: diamond label:"Retryable error?" +n11: diamond label:"Retries remaining?" +n12: rectangle label:"Calculate backoff delay" +n13: rectangle label:"Wait exponential delay" +n14: rectangle label:"Increment retry counter" +n15: rectangle label:"Return final error" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="2xx"] +n8.handle(bottom) -> n10.handle(top) [label="4xx/5xx"] +n9.handle(top) -> Client.n3.handle(bottom) [label="Success"] +n10.handle(right) -> n11.handle(left) [label="Yes"] +n10.handle(bottom) -> n15.handle(top) [label="No"] +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n15.handle(top) [label="No"] +n12.handle(right) -> n13.handle(left) +n13.handle(right) -> n14.handle(left) +n14.handle(top) -> n7.handle(bottom) [label="Retry"] +n15.handle(top) -> Client.n4.handle(bottom) [label="Failed"] +loop [retry up to 3 times] n7 n8 n10 n11 n12 n13 n14 +} +APIServer { # API Server +n16: rectangle label:"Receive request" +n17: diamond label:"Server healthy?" +n18: rectangle label:"Process request" +n19: rectangle label:"Return 503 Service Unavailable" +n20: rectangle label:"Return 200 OK" +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(right) -> n20.handle(left) +n19.handle(top) -> RetryHandler.n8.handle(bottom) [label="Error"] +n20.handle(top) -> RetryHandler.n8.handle(bottom) [label="Success"] +} diff --git a/uncategorized/patterns/router-workflow/README.md b/uncategorized/patterns/router-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7a9fdc56ded6efab759b0439f748bb3ef3d0ef0c --- /dev/null +++ b/uncategorized/patterns/router-workflow/README.md @@ -0,0 +1,19 @@ +# Router Workflow + +This workflow models routing messages based on their content. + +**Template ID:** `router-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 3/5 +**Nodes:** 10 +**Lanes:** 3 +**Tags:** [router, patterns, decision] +**Source path:** `patterns/router` +**Repo path:** `uncategorized/patterns/router-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/router-workflow/metadata.json b/uncategorized/patterns/router-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..67dfe4bbc390b2dab1e36e79d04b010fd96b189e --- /dev/null +++ b/uncategorized/patterns/router-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "router-workflow", + "workflow_id": "router", + "title": "Router Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 3, + "num_nodes": 10, + "num_lanes": 3, + "tags": [ + "router", + "patterns", + "decision" + ], + "description": "This workflow models routing messages based on their content.", + "source_path": "patterns/router", + "repo_path": "uncategorized/patterns/router-workflow" +} diff --git a/uncategorized/patterns/router-workflow/workflow.fz b/uncategorized/patterns/router-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..57997c42ecb216bf008efa6c9426720333fd6b2d --- /dev/null +++ b/uncategorized/patterns/router-workflow/workflow.fz @@ -0,0 +1,28 @@ +user { # User + n1: circle label:"Start Router" + n2: diamond label:"Receive Router event" + n4: rectangle label:"Execute Router action" + n7: rectangle label:"Monitor Router status" + n10: circle label:"End Router" + n1.handle(right) -> n2.handle(left) + n2.handle(bottom) -> service.n3.handle(top) [label="Yes/Approved"] + n4.handle(bottom) -> app.n5.handle(top) + n7.handle(bottom) -> app.n8.handle(top) + n2.handle(top) -> n4.handle(top) [label="No/Rejected"] +} + +app { # App + n5: rectangle label:"Record Router outcome" + n8: rectangle label:"Monitor Router status" + n5.handle(bottom) -> service.n6.handle(top) + n8.handle(bottom) -> service.n9.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Router conditions" + n6: rectangle label:"Monitor Router status" + n9: rectangle label:"Monitor Router status" + n9.handle(right) -> user.n10.handle(bottom) + n6.handle(right) -> user.n7.handle(left) + n3.handle(right) -> app.n5.handle(left) +} diff --git a/uncategorized/patterns/snapshot-pattern-workflow/README.md b/uncategorized/patterns/snapshot-pattern-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c62a42658bad66a134d75258f45a79a696a6e9d0 --- /dev/null +++ b/uncategorized/patterns/snapshot-pattern-workflow/README.md @@ -0,0 +1,19 @@ +# Snapshot Pattern Workflow + +This workflow models taking periodic snapshots of important state. + +**Template ID:** `snapshot-pattern-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [snapshot, pattern, patterns, decision, loop] +**Source path:** `patterns/snapshot-pattern` +**Repo path:** `uncategorized/patterns/snapshot-pattern-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/snapshot-pattern-workflow/metadata.json b/uncategorized/patterns/snapshot-pattern-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..a41dfd4e75cc320371caea585c72114ca5446229 --- /dev/null +++ b/uncategorized/patterns/snapshot-pattern-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "snapshot-pattern-workflow", + "workflow_id": "snapshot-pattern", + "title": "Snapshot Pattern Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "snapshot", + "pattern", + "patterns", + "decision", + "loop" + ], + "description": "This workflow models taking periodic snapshots of important state.", + "source_path": "patterns/snapshot-pattern", + "repo_path": "uncategorized/patterns/snapshot-pattern-workflow" +} diff --git a/uncategorized/patterns/snapshot-pattern-workflow/workflow.fz b/uncategorized/patterns/snapshot-pattern-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..6ceafdc0471958c67fdaff97504f992573a1e77a --- /dev/null +++ b/uncategorized/patterns/snapshot-pattern-workflow/workflow.fz @@ -0,0 +1,19 @@ +user { # User + n1: circle label:"Start Snapshot Pattern" + n2: diamond label:"Receive Snapshot Pattern event" + n3: rectangle label:"Validate Snapshot Pattern conditions" + n5: rectangle label:"Record Snapshot Pattern outcome" + n7: circle label:"End Snapshot Pattern" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> app.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> app.n6.handle(top) +} + +app { # App + n4: rectangle label:"Execute Snapshot Pattern action" + n6: rectangle label:"Monitor Snapshot Pattern status" + n6.handle(right) -> user.n7.handle(bottom) + n4.handle(right) -> user.n5.handle(top) +} diff --git a/uncategorized/patterns/state-machine-workflow/README.md b/uncategorized/patterns/state-machine-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d62c877952076ae6aae8e6d4b2447abf4f5482d7 --- /dev/null +++ b/uncategorized/patterns/state-machine-workflow/README.md @@ -0,0 +1,19 @@ +# State Machine Workflow + +This workflow models tracking object state changes over time. + +**Template ID:** `state-machine-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [state, machine, patterns, parallel] +**Source path:** `patterns/state-machine` +**Repo path:** `uncategorized/patterns/state-machine-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/state-machine-workflow/metadata.json b/uncategorized/patterns/state-machine-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..28ec06e68658bfe893d461ea1ca393eae14a8ce3 --- /dev/null +++ b/uncategorized/patterns/state-machine-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "state-machine-workflow", + "workflow_id": "state-machine", + "title": "State Machine Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "state", + "machine", + "patterns", + "parallel" + ], + "description": "This workflow models tracking object state changes over time.", + "source_path": "patterns/state-machine", + "repo_path": "uncategorized/patterns/state-machine-workflow" +} diff --git a/uncategorized/patterns/state-machine-workflow/workflow.fz b/uncategorized/patterns/state-machine-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..dd4da30cba179a9a9ab0cba69b6f25575fce291d --- /dev/null +++ b/uncategorized/patterns/state-machine-workflow/workflow.fz @@ -0,0 +1,47 @@ +OrderSystem { # Order System +n1: circle label:"Start" +n2: rectangle label:"Receive order event" +n3: rectangle label:"Load current state" +n4: rectangle label:"Order completed" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> StateMachine.n6.handle(top) [label="Process"] +n4.handle(right) -> n5.handle(left) +} +StateMachine { # State Machine +n6: diamond label:"Current state?" +n7: rectangle label:"Pending to Confirmed" +n8: rectangle label:"Confirmed to Processing" +n9: rectangle label:"Processing to Shipped" +n10: rectangle label:"Shipped to Delivered" +n11: rectangle label:"Any to Cancelled" +n12: diamond label:"Valid transition?" +n13: rectangle label:"Update state" +n14: rectangle label:"Reject invalid transition" +n6.handle(right) -> n7.handle(left) [label="Pending"] +n6.handle(bottom) -> n8.handle(top) [label="Confirmed"] +n6.handle(left) -> n9.handle(top) [label="Processing"] +n7.handle(bottom) -> n12.handle(top) +n8.handle(bottom) -> n12.handle(top) +n9.handle(bottom) -> n12.handle(top) +n10.handle(bottom) -> n12.handle(top) +n11.handle(bottom) -> n12.handle(top) +n12.handle(right) -> n13.handle(left) [label="Yes"] +n12.handle(bottom) -> n14.handle(top) [label="No"] +n13.handle(bottom) -> EventLog.n15.handle(top) [label="Persist"] +n14.handle(top) -> OrderSystem.n4.handle(bottom) [label="Error"] +} +EventLog { # Event Log +n15: rectangle label:"Record state transition" +n16: rectangle label:"Emit state changed event" +n17: diamond label:"Final state?" +n18: rectangle label:"Trigger completion handlers" +n19: rectangle label:"Continue processing" +n15.handle(right) -> n16.handle(left) +n16.handle(right) -> n17.handle(left) +n17.handle(right) -> n18.handle(left) [label="Yes"] +n17.handle(bottom) -> n19.handle(top) [label="No"] +n18.handle(top) -> OrderSystem.n4.handle(bottom) [label="Complete"] +n19.handle(top) -> OrderSystem.n4.handle(bottom) [label="Updated"] +} diff --git a/uncategorized/patterns/strangler-fig-workflow/README.md b/uncategorized/patterns/strangler-fig-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d0972bf7b38ba1ed2e0098e878216546f60b7374 --- /dev/null +++ b/uncategorized/patterns/strangler-fig-workflow/README.md @@ -0,0 +1,19 @@ +# Strangler Fig Workflow + +This workflow models gradually replacing an old system with a new one. + +**Template ID:** `strangler-fig-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [strangler, fig, patterns, decision] +**Source path:** `patterns/strangler-fig` +**Repo path:** `uncategorized/patterns/strangler-fig-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/strangler-fig-workflow/metadata.json b/uncategorized/patterns/strangler-fig-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..4cec110eaba8fbf4d2ca44025c60cf35c9f161eb --- /dev/null +++ b/uncategorized/patterns/strangler-fig-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "strangler-fig-workflow", + "workflow_id": "strangler-fig", + "title": "Strangler Fig Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "strangler", + "fig", + "patterns", + "decision" + ], + "description": "This workflow models gradually replacing an old system with a new one.", + "source_path": "patterns/strangler-fig", + "repo_path": "uncategorized/patterns/strangler-fig-workflow" +} diff --git a/uncategorized/patterns/strangler-fig-workflow/workflow.fz b/uncategorized/patterns/strangler-fig-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..e0e1763b6510c21bbd66961cf7bdd2fb7ae2dcb1 --- /dev/null +++ b/uncategorized/patterns/strangler-fig-workflow/workflow.fz @@ -0,0 +1,19 @@ +user { # User + n1: circle label:"Start Strangler Fig" + n2: diamond label:"Receive Strangler Fig event" + n3: rectangle label:"Validate Strangler Fig conditions" + n5: rectangle label:"Record Strangler Fig outcome" + n7: circle label:"End Strangler Fig" + n1.handle(right) -> n2.handle(left) + n2.handle(right) -> n3.handle(left) [label="Yes/Approved"] + n2.handle(bottom) -> app.n4.handle(top) [label="No/Rejected"] + n3.handle(right) -> n5.handle(left) + n5.handle(bottom) -> app.n6.handle(top) +} + +app { # App + n4: rectangle label:"Execute Strangler Fig action" + n6: rectangle label:"Monitor Strangler Fig status" + n4.handle(right) -> user.n5.handle(left) + n6.handle(right) -> user.n7.handle(bottom) +} diff --git a/uncategorized/patterns/timeout-pattern-workflow/README.md b/uncategorized/patterns/timeout-pattern-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c9bce3d5eef9cfa049a3725a2ed1c86e5a845b02 --- /dev/null +++ b/uncategorized/patterns/timeout-pattern-workflow/README.md @@ -0,0 +1,19 @@ +# Timeout Pattern Workflow + +This workflow models an operation that times out after a delay. + +**Template ID:** `timeout-pattern-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [timeout, pattern, patterns] +**Source path:** `patterns/timeout-pattern` +**Repo path:** `uncategorized/patterns/timeout-pattern-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/timeout-pattern-workflow/metadata.json b/uncategorized/patterns/timeout-pattern-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..ac244de3275a5948f931e44eeb24778688dec3f4 --- /dev/null +++ b/uncategorized/patterns/timeout-pattern-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "timeout-pattern-workflow", + "workflow_id": "timeout-pattern", + "title": "Timeout Pattern Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "timeout", + "pattern", + "patterns" + ], + "description": "This workflow models an operation that times out after a delay.", + "source_path": "patterns/timeout-pattern", + "repo_path": "uncategorized/patterns/timeout-pattern-workflow" +} diff --git a/uncategorized/patterns/timeout-pattern-workflow/workflow.fz b/uncategorized/patterns/timeout-pattern-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..2ac40161f55a005189b3e8ebcc4c0d1a0fdd2209 --- /dev/null +++ b/uncategorized/patterns/timeout-pattern-workflow/workflow.fz @@ -0,0 +1,37 @@ +user { # User + n1: circle label:"Start Timeout Pattern" + n5: diamond label:"Record Timeout Pattern outcome" + n9: rectangle label:"Monitor Timeout Pattern status" + n13: circle label:"End Timeout Pattern" + n1.handle(bottom) -> app.n2.handle(top) + n5.handle(bottom) -> app.n6.handle(top) + n5.handle(right) -> database.n4.handle(right) [label="Retry/Rejected"] + n9.handle(bottom) -> app.n10.handle(top) [label="Valid"] +} + +app { # App + n2: rectangle label:"Receive Timeout Pattern event" + n6: rectangle label:"Monitor Timeout Pattern status" + n10: rectangle label:"Monitor Timeout Pattern status" + n2.handle(bottom) -> service.n3.handle(top) + n6.handle(bottom) -> service.n7.handle(top) [label="Success"] + n10.handle(bottom) -> service.n11.handle(top) +} + +service { # Service + n3: rectangle label:"Validate Timeout Pattern conditions" + n7: rectangle label:"Monitor Timeout Pattern status" + n11: rectangle label:"Monitor Timeout Pattern status" + n3.handle(bottom) -> database.n4.handle(top) [label="Processed"] + n7.handle(bottom) -> database.n8.handle(top) + n11.handle(bottom) -> database.n12.handle(top) +} + +database { # Database + n4: rectangle label:"Execute Timeout Pattern action" + n8: rectangle label:"Monitor Timeout Pattern status" + n12: rectangle label:"Monitor Timeout Pattern status" + n12.handle(right) -> user.n13.handle(bottom) [label="Next"] + n8.handle(right) -> user.n9.handle(left) + n4.handle(bottom) -> user.n5.handle(left) +} diff --git a/uncategorized/patterns/transactional-outbox-workflow/README.md b/uncategorized/patterns/transactional-outbox-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7a9f4cfc601eb64e57055fa5d4f55b1e586c421b --- /dev/null +++ b/uncategorized/patterns/transactional-outbox-workflow/README.md @@ -0,0 +1,19 @@ +# Transactional Outbox Workflow + +This workflow models writing data and publishing messages in one transaction. + +**Template ID:** `transactional-outbox-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 4/5 +**Nodes:** 13 +**Lanes:** 4 +**Tags:** [transactional, outbox, patterns, parallel] +**Source path:** `patterns/transactional-outbox` +**Repo path:** `uncategorized/patterns/transactional-outbox-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/transactional-outbox-workflow/metadata.json b/uncategorized/patterns/transactional-outbox-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f2d536c77b85b8ada7801c8a187b360cd68936fe --- /dev/null +++ b/uncategorized/patterns/transactional-outbox-workflow/metadata.json @@ -0,0 +1,22 @@ +{ + "template_id": "transactional-outbox-workflow", + "workflow_id": "transactional-outbox", + "title": "Transactional Outbox Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 4, + "num_nodes": 13, + "num_lanes": 4, + "tags": [ + "transactional", + "outbox", + "patterns", + "parallel" + ], + "description": "This workflow models writing data and publishing messages in one transaction.", + "source_path": "patterns/transactional-outbox", + "repo_path": "uncategorized/patterns/transactional-outbox-workflow" +} diff --git a/uncategorized/patterns/transactional-outbox-workflow/workflow.fz b/uncategorized/patterns/transactional-outbox-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..ab8a6788d0dc460d125cb9cfbf7995adebdcc04f --- /dev/null +++ b/uncategorized/patterns/transactional-outbox-workflow/workflow.fz @@ -0,0 +1,46 @@ +user { # User + n1: circle label:"Start Transactional Outbox" + n5: rectangle label:"Record Transactional Outbox outcome" + n9: rectangle label:"Monitor Transactional Outbox status" + n13: circle label:"End Transactional Outbox" + n1.handle(bottom) -> app.n2.handle(top) + n1.handle(bottom) -> service.n3.handle(top) + n1.handle(bottom) -> database.n4.handle(top) + n1.handle(right) -> n5.handle(left) + n1.handle(bottom) -> app.n6.handle(top) + n1.handle(bottom) -> service.n7.handle(top) + n1.handle(bottom) -> database.n8.handle(top) + n1.handle(bottom) -> app.n10.handle(top) + n1.handle(bottom) -> service.n11.handle(top) + n1.handle(bottom) -> database.n12.handle(top) + n9.handle(right) -> n13.handle(left) + n5.handle(right) -> n13.handle(top) + n1.handle(right) -> n9.handle(bottom) +} + +app { # App + n2: rectangle label:"Receive Transactional Outbox event" + n6: rectangle label:"Monitor Transactional Outbox status" + n10: rectangle label:"Monitor Transactional Outbox status" + n10.handle(right) -> user.n13.handle(bottom) + n6.handle(right) -> user.n13.handle(bottom) + n2.handle(right) -> user.n13.handle(bottom) +} + +service { # Service + n3: rectangle label:"Validate Transactional Outbox conditions" + n7: rectangle label:"Monitor Transactional Outbox status" + n11: rectangle label:"Monitor Transactional Outbox status" + n11.handle(right) -> user.n13.handle(bottom) + n7.handle(right) -> user.n13.handle(bottom) + n3.handle(right) -> user.n13.handle(bottom) +} + +database { # Database + n4: diamond label:"Execute Transactional Outbox action" + n8: rectangle label:"Monitor Transactional Outbox status" + n12: diamond label:"Monitor Transactional Outbox status" + n12.handle(right) -> user.n13.handle(bottom) + n8.handle(right) -> user.n13.handle(bottom) + n4.handle(right) -> user.n13.handle(bottom) +} diff --git a/uncategorized/patterns/transform-workflow/README.md b/uncategorized/patterns/transform-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ad66a1b8481961c51f94233998e9a1380cdec799 --- /dev/null +++ b/uncategorized/patterns/transform-workflow/README.md @@ -0,0 +1,19 @@ +# Transform Workflow + +This workflow models converting messages into a new shape. + +**Template ID:** `transform-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [transform, patterns] +**Source path:** `patterns/transform` +**Repo path:** `uncategorized/patterns/transform-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/transform-workflow/metadata.json b/uncategorized/patterns/transform-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..5c66867d2262a54902960c587d3b45e780cd40ed --- /dev/null +++ b/uncategorized/patterns/transform-workflow/metadata.json @@ -0,0 +1,20 @@ +{ + "template_id": "transform-workflow", + "workflow_id": "transform", + "title": "Transform Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "transform", + "patterns" + ], + "description": "This workflow models converting messages into a new shape.", + "source_path": "patterns/transform", + "repo_path": "uncategorized/patterns/transform-workflow" +} diff --git a/uncategorized/patterns/transform-workflow/workflow.fz b/uncategorized/patterns/transform-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..2bd64df2a2c8e59b8832be492b0bd09218512a3e --- /dev/null +++ b/uncategorized/patterns/transform-workflow/workflow.fz @@ -0,0 +1,19 @@ +user { # User + n1: circle label:"Start Transform" + n3: rectangle label:"Validate Transform conditions" + n5: diamond label:"Record Transform outcome" + n7: circle label:"End Transform" + n1.handle(bottom) -> app.n2.handle(top) + n3.handle(bottom) -> app.n4.handle(top) [label="Processed"] + n5.handle(bottom) -> app.n6.handle(top) + n5.handle(right) -> app.n4.handle(right) [label="Retry/Rejected"] +} + +app { # App + n2: rectangle label:"Receive Transform event" + n4: rectangle label:"Execute Transform action" + n6: rectangle label:"Monitor Transform status" + n6.handle(right) -> user.n7.handle(bottom) [label="Success"] + n4.handle(bottom) -> user.n5.handle(left) + n2.handle(right) -> user.n3.handle(left) +} diff --git a/uncategorized/patterns/validator-workflow/README.md b/uncategorized/patterns/validator-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b696ed2b151a620b5867d5530d24dad24c97ae37 --- /dev/null +++ b/uncategorized/patterns/validator-workflow/README.md @@ -0,0 +1,19 @@ +# Validator Workflow + +This workflow models checking that incoming data is valid. + +**Template ID:** `validator-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [validator, patterns, parallel] +**Source path:** `patterns/validator` +**Repo path:** `uncategorized/patterns/validator-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/validator-workflow/metadata.json b/uncategorized/patterns/validator-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..31a00b5433661f681d291705776080fb3b92e4f1 --- /dev/null +++ b/uncategorized/patterns/validator-workflow/metadata.json @@ -0,0 +1,21 @@ +{ + "template_id": "validator-workflow", + "workflow_id": "validator", + "title": "Validator Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "validator", + "patterns", + "parallel" + ], + "description": "This workflow models checking that incoming data is valid.", + "source_path": "patterns/validator", + "repo_path": "uncategorized/patterns/validator-workflow" +} diff --git a/uncategorized/patterns/validator-workflow/workflow.fz b/uncategorized/patterns/validator-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..3cce3559e8099422cafdf06018d316a900fe6603 --- /dev/null +++ b/uncategorized/patterns/validator-workflow/workflow.fz @@ -0,0 +1,22 @@ +user { # User + n1: circle label:"Start Validator" + n3: rectangle label:"Validate Validator conditions" + n5: rectangle label:"Record Validator outcome" + n7: circle label:"End Validator" + n1.handle(bottom) -> app.n2.handle(top) + n1.handle(right) -> n3.handle(left) + n1.handle(bottom) -> app.n4.handle(top) + n1.handle(bottom) -> app.n6.handle(top) + n5.handle(right) -> n7.handle(left) + n3.handle(top) -> n7.handle(top) + n1.handle(right) -> n5.handle(bottom) +} + +app { # App + n2: rectangle label:"Receive Validator event" + n4: rectangle label:"Execute Validator action" + n6: diamond label:"Monitor Validator status" + n6.handle(right) -> user.n7.handle(bottom) + n4.handle(right) -> user.n7.handle(bottom) + n2.handle(right) -> user.n7.handle(bottom) +} diff --git a/uncategorized/patterns/webhook-pattern-workflow/README.md b/uncategorized/patterns/webhook-pattern-workflow/README.md new file mode 100644 index 0000000000000000000000000000000000000000..018232e969780478229b0435ec66788ba66c14dc --- /dev/null +++ b/uncategorized/patterns/webhook-pattern-workflow/README.md @@ -0,0 +1,19 @@ +# Webhook Pattern Workflow + +This workflow models an HTTP callback when an event occurs. + +**Template ID:** `webhook-pattern-workflow` +**Kind:** workflow +**Source domain:** patterns +**Primary use case:** uncategorized +**Secondary use cases:** None +**Complexity:** 2/5 +**Nodes:** 7 +**Lanes:** 2 +**Tags:** [webhook, pattern, patterns, decision, loop] +**Source path:** `patterns/webhook-pattern` +**Repo path:** `uncategorized/patterns/webhook-pattern-workflow` + +## Files +- `workflow.fz` — FlowZap Code source +- `metadata.json` — Structured metadata diff --git a/uncategorized/patterns/webhook-pattern-workflow/metadata.json b/uncategorized/patterns/webhook-pattern-workflow/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..f58f9dd9cdc5accd33818c6b03a9907d4f24962e --- /dev/null +++ b/uncategorized/patterns/webhook-pattern-workflow/metadata.json @@ -0,0 +1,23 @@ +{ + "template_id": "webhook-pattern-workflow", + "workflow_id": "webhook-pattern", + "title": "Webhook Pattern Workflow", + "kind": "workflow", + "source_domain": "patterns", + "primary_use_case": "uncategorized", + "secondary_use_cases": [], + "use_cases": [], + "complexity": 2, + "num_nodes": 7, + "num_lanes": 2, + "tags": [ + "webhook", + "pattern", + "patterns", + "decision", + "loop" + ], + "description": "This workflow models an HTTP callback when an event occurs.", + "source_path": "patterns/webhook-pattern", + "repo_path": "uncategorized/patterns/webhook-pattern-workflow" +} diff --git a/uncategorized/patterns/webhook-pattern-workflow/workflow.fz b/uncategorized/patterns/webhook-pattern-workflow/workflow.fz new file mode 100644 index 0000000000000000000000000000000000000000..92815dce662cd0ef8db69e56d03bbf02613264de --- /dev/null +++ b/uncategorized/patterns/webhook-pattern-workflow/workflow.fz @@ -0,0 +1,47 @@ +Sender { # Webhook Sender +n1: circle label:"Start" +n2: rectangle label:"Event occurs in system" +n3: rectangle label:"Build webhook payload" +n4: rectangle label:"Log delivery result" +n5: circle label:"End" +n1.handle(right) -> n2.handle(left) +n2.handle(right) -> n3.handle(left) +n3.handle(bottom) -> Delivery.n6.handle(top) [label="Send"] +n4.handle(right) -> n5.handle(left) +} +Delivery { # Webhook Delivery +n6: rectangle label:"Sign payload with HMAC" +n7: rectangle label:"POST to subscriber URL" +n8: diamond label:"Response status?" +n9: rectangle label:"Mark as delivered" +n10: rectangle label:"Schedule retry" +n11: diamond label:"Max retries reached?" +n12: rectangle label:"Mark as failed" +n6.handle(right) -> n7.handle(left) +n7.handle(right) -> n8.handle(left) +n8.handle(right) -> n9.handle(left) [label="2xx"] +n8.handle(bottom) -> n10.handle(top) [label="4xx/5xx"] +n9.handle(top) -> Sender.n4.handle(bottom) [label="Success"] +n10.handle(right) -> n11.handle(left) +n11.handle(right) -> n12.handle(left) [label="Yes"] +n11.handle(bottom) -> n7.handle(bottom) [label="No"] +n12.handle(top) -> Sender.n4.handle(bottom) [label="Failed"] +loop [retry up to 5 times] n7 n8 n10 n11 +} +Receiver { # Webhook Receiver +n13: rectangle label:"Receive POST request" +n14: rectangle label:"Verify HMAC signature" +n15: diamond label:"Signature valid?" +n16: rectangle label:"Parse JSON payload" +n17: rectangle label:"Return 401 Unauthorized" +n18: rectangle label:"Process event" +n19: rectangle label:"Return 200 OK" +n13.handle(right) -> n14.handle(left) +n14.handle(right) -> n15.handle(left) +n15.handle(right) -> n16.handle(left) [label="Yes"] +n15.handle(bottom) -> n17.handle(top) [label="No"] +n16.handle(right) -> n18.handle(left) +n17.handle(top) -> Sender.n4.handle(bottom) [label="Rejected"] +n18.handle(right) -> n19.handle(left) +n19.handle(top) -> Sender.n4.handle(bottom) [label="Processed"] +} diff --git a/use-cases.index.json b/use-cases.index.json new file mode 100644 index 0000000000000000000000000000000000000000..4a4433594cf91cbad241d37dd83aa94ba2cfb52a --- /dev/null +++ b/use-cases.index.json @@ -0,0 +1,1304 @@ +{ + "useCases": { + "handoff": { + "label": "Handoff", + "count": 15, + "templates": [ + { + "slug": "api-gateway-workflow", + "title": "Api Gateway Workflow", + "repoPath": "handoff/patterns/api-gateway-workflow" + }, + { + "slug": "escalation-pattern-workflow", + "title": "Escalation Pattern Workflow", + "repoPath": "handoff/patterns/escalation-pattern-workflow" + }, + { + "slug": "offboarding-workflow", + "title": "Offboarding Workflow", + "repoPath": "handoff/hr/offboarding-workflow" + }, + { + "slug": "on-call-rotation-workflow", + "title": "On Call Rotation Workflow", + "repoPath": "handoff/devops/on-call-rotation-workflow" + }, + { + "slug": "payment-run-workflow", + "title": "Payment Run Workflow", + "repoPath": "handoff/finance/payment-run-workflow" + }, + { + "slug": "routing-slip-workflow", + "title": "Routing Slip Workflow", + "repoPath": "handoff/patterns/routing-slip-workflow" + }, + { + "slug": "stock-transfer-workflow", + "title": "Stock Transfer Workflow", + "repoPath": "handoff/logistics/stock-transfer-workflow" + }, + { + "slug": "support-ticket-workflow", + "title": "Support Ticket Workflow", + "repoPath": "handoff/business-operations/support-ticket-workflow" + }, + { + "slug": "warehouse-transfer-workflow", + "title": "Warehouse Transfer Workflow", + "repoPath": "handoff/logistics/warehouse-transfer-workflow" + }, + { + "slug": "microservices-service-discovery-architecture", + "title": "Microservices Service Discovery Architecture", + "repoPath": "handoff/architecture/microservices-service-discovery-architecture" + }, + { + "slug": "serverless-edge-computing-architecture", + "title": "Serverless Edge Computing Architecture", + "repoPath": "handoff/architecture/serverless-edge-computing-architecture" + }, + { + "slug": "serverless-multi-cloud-architecture", + "title": "Serverless Multi-Cloud Architecture", + "repoPath": "handoff/architecture/serverless-multi-cloud-architecture" + }, + { + "slug": "bulkhead-isolation-architecture", + "title": "Bulkhead Isolation Architecture", + "repoPath": "handoff/architecture/bulkhead-isolation-architecture" + }, + { + "slug": "cell-based-architecture", + "title": "Cell-Based Architecture", + "repoPath": "handoff/architecture/cell-based-architecture" + }, + { + "slug": "mcp-tool-router", + "title": "MCP Tool Router Architecture", + "repoPath": "handoff/devops/mcp-tool-router" + } + ] + }, + "approval": { + "label": "Approval", + "count": 17, + "templates": [ + { + "slug": "access-review-workflow", + "title": "Access Review Workflow", + "repoPath": "approval/devops/access-review-workflow" + }, + { + "slug": "authorization-flow-workflow", + "title": "Authorization Flow Workflow", + "repoPath": "approval/patterns/authorization-flow-workflow" + }, + { + "slug": "billing-dispute-workflow", + "title": "Billing Dispute Workflow", + "repoPath": "approval/business-operations/billing-dispute-workflow" + }, + { + "slug": "budget-approval-workflow", + "title": "Budget Approval Workflow", + "repoPath": "approval/finance/budget-approval-workflow" + }, + { + "slug": "database-migration-workflow", + "title": "Database Migration Workflow", + "repoPath": "approval/devops/database-migration-workflow" + }, + { + "slug": "expense-approval-workflow", + "title": "Expense Approval Workflow", + "repoPath": "approval/hr/expense-approval-workflow" + }, + { + "slug": "expense-claim-workflow", + "title": "Expense Claim Workflow", + "repoPath": "approval/finance/expense-claim-workflow" + }, + { + "slug": "insurance-claim-workflow", + "title": "Insurance Claim Workflow", + "repoPath": "approval/finance/insurance-claim-workflow" + }, + { + "slug": "invoice-processing-workflow", + "title": "Invoice Processing Workflow", + "repoPath": "approval/finance/invoice-processing-workflow" + }, + { + "slug": "oauth-flow-workflow", + "title": "Oauth Flow Workflow", + "repoPath": "approval/business-operations/oauth-flow-workflow" + }, + { + "slug": "performance-review-workflow", + "title": "Performance Review Workflow", + "repoPath": "approval/hr/performance-review-workflow" + }, + { + "slug": "pto-request-workflow", + "title": "Pto Request Workflow", + "repoPath": "approval/hr/pto-request-workflow" + }, + { + "slug": "purchase-order-workflow", + "title": "Purchase Order Workflow", + "repoPath": "approval/finance/purchase-order-workflow" + }, + { + "slug": "review-collection-workflow", + "title": "Review Collection Workflow", + "repoPath": "approval/business-operations/review-collection-workflow" + }, + { + "slug": "salary-increase-workflow", + "title": "Salary Increase Workflow", + "repoPath": "approval/hr/salary-increase-workflow" + }, + { + "slug": "termination-process-workflow", + "title": "Termination Process Workflow", + "repoPath": "approval/hr/termination-process-workflow" + }, + { + "slug": "saga-order-fulfillment-architecture", + "title": "Saga Order Fulfillment Architecture", + "repoPath": "approval/architecture/saga-order-fulfillment-architecture" + } + ] + }, + "incident": { + "label": "Incident", + "count": 10, + "templates": [ + { + "slug": "canary-deploy-workflow", + "title": "Canary Deploy Workflow", + "repoPath": "incident/patterns/canary-deploy-workflow" + }, + { + "slug": "cold-chain-monitoring-workflow", + "title": "Cold Chain Monitoring Workflow", + "repoPath": "incident/logistics/cold-chain-monitoring-workflow" + }, + { + "slug": "deployment-rollback-workflow", + "title": "Deployment Rollback Workflow", + "repoPath": "incident/devops/deployment-rollback-workflow" + }, + { + "slug": "hazmat-handling-workflow", + "title": "Hazmat Handling Workflow", + "repoPath": "incident/logistics/hazmat-handling-workflow" + }, + { + "slug": "incident-response-workflow", + "title": "Incident Response Workflow", + "repoPath": "incident/devops/incident-response-workflow" + }, + { + "slug": "monitoring-alert-workflow", + "title": "Monitoring Alert Workflow", + "repoPath": "incident/devops/monitoring-alert-workflow" + }, + { + "slug": "event-driven-dead-letter-queue-architecture", + "title": "Event-Driven Dead Letter Queue Architecture", + "repoPath": "incident/architecture/event-driven-dead-letter-queue-architecture" + }, + { + "slug": "serverless-step-functions-orchestration-architecture", + "title": "Serverless Step Functions Orchestration Architecture", + "repoPath": "incident/architecture/serverless-step-functions-orchestration-architecture" + }, + { + "slug": "health-check-pattern-architecture", + "title": "Health Check Pattern Architecture", + "repoPath": "incident/architecture/health-check-pattern-architecture" + }, + { + "slug": "api-composition-pattern-architecture", + "title": "API Composition Pattern Architecture", + "repoPath": "incident/architecture/api-composition-pattern-architecture" + } + ] + }, + "onboarding": { + "label": "Onboarding", + "count": 6, + "templates": [ + { + "slug": "ab-test-setup-workflow", + "title": "Ab Test Setup Workflow", + "repoPath": "onboarding/business-operations/ab-test-setup-workflow" + }, + { + "slug": "onboarding-workflow", + "title": "Onboarding Workflow", + "repoPath": "onboarding/hr/onboarding-workflow" + }, + { + "slug": "two-factor-setup-workflow", + "title": "Two Factor Setup Workflow", + "repoPath": "onboarding/business-operations/two-factor-setup-workflow" + }, + { + "slug": "user-onboarding-workflow", + "title": "User Onboarding Workflow", + "repoPath": "onboarding/business-operations/user-onboarding-workflow" + }, + { + "slug": "vendor-onboarding-workflow", + "title": "Vendor Onboarding Workflow", + "repoPath": "onboarding/finance/vendor-onboarding-workflow" + }, + { + "slug": "webinar-registration-workflow", + "title": "Webinar Registration Workflow", + "repoPath": "onboarding/business-operations/webinar-registration-workflow" + } + ] + }, + "offboarding": { + "label": "Offboarding", + "count": 1, + "templates": [ + { + "slug": "account-deletion-workflow", + "title": "Account Deletion Workflow", + "repoPath": "offboarding/business-operations/account-deletion-workflow" + } + ] + }, + "billing": { + "label": "Billing & Payments", + "count": 8, + "templates": [ + { + "slug": "conflict-resolution-workflow", + "title": "Conflict Resolution Workflow", + "repoPath": "billing/hr/conflict-resolution-workflow" + }, + { + "slug": "dunning-flow-workflow", + "title": "Dunning Flow Workflow", + "repoPath": "billing/business-operations/dunning-flow-workflow" + }, + { + "slug": "payment-failure-workflow", + "title": "Payment Failure Workflow", + "repoPath": "billing/business-operations/payment-failure-workflow" + }, + { + "slug": "plan-downgrade-workflow", + "title": "Plan Downgrade Workflow", + "repoPath": "billing/business-operations/plan-downgrade-workflow" + }, + { + "slug": "plan-upgrade-workflow", + "title": "Plan Upgrade Workflow", + "repoPath": "billing/business-operations/plan-upgrade-workflow" + }, + { + "slug": "returns-processing-workflow", + "title": "Returns Processing Workflow", + "repoPath": "billing/logistics/returns-processing-workflow" + }, + { + "slug": "subscription-lifecycle-workflow", + "title": "Subscription Lifecycle Workflow", + "repoPath": "billing/business-operations/subscription-lifecycle-workflow" + }, + { + "slug": "shopify-universal-commerce-protocol", + "title": "Shopify Universal Commerce Protocol", + "repoPath": "billing/business-operations/shopify-universal-commerce-protocol" + } + ] + }, + "security": { + "label": "Security & Access", + "count": 13, + "templates": [ + { + "slug": "api-key-rotation-workflow", + "title": "Api Key Rotation Workflow", + "repoPath": "security/business-operations/api-key-rotation-workflow" + }, + { + "slug": "authentication-flow-workflow", + "title": "Authentication Flow Workflow", + "repoPath": "security/patterns/authentication-flow-workflow" + }, + { + "slug": "certificate-renewal-workflow", + "title": "Certificate Renewal Workflow", + "repoPath": "security/devops/certificate-renewal-workflow" + }, + { + "slug": "secret-rotation-workflow", + "title": "Secret Rotation Workflow", + "repoPath": "security/devops/secret-rotation-workflow" + }, + { + "slug": "security-scan-workflow", + "title": "Security Scan Workflow", + "repoPath": "security/devops/security-scan-workflow" + }, + { + "slug": "shipping-process-workflow", + "title": "Shipping Process Workflow", + "repoPath": "security/logistics/shipping-process-workflow" + }, + { + "slug": "sms-verification-workflow", + "title": "Sms Verification Workflow", + "repoPath": "security/business-operations/sms-verification-workflow" + }, + { + "slug": "vulnerability-patch-workflow", + "title": "Vulnerability Patch Workflow", + "repoPath": "security/devops/vulnerability-patch-workflow" + }, + { + "slug": "microservices-api-gateway-architecture", + "title": "Microservices API Gateway Architecture", + "repoPath": "security/architecture/microservices-api-gateway-architecture" + }, + { + "slug": "event-driven-domain-events-architecture", + "title": "Event-Driven Domain Events Architecture", + "repoPath": "security/architecture/event-driven-domain-events-architecture" + }, + { + "slug": "zero-trust-security-architecture", + "title": "Zero Trust Security Architecture", + "repoPath": "security/architecture/zero-trust-security-architecture" + }, + { + "slug": "multi-tenant-saas-architecture", + "title": "Multi-Tenant SaaS Architecture", + "repoPath": "security/architecture/multi-tenant-saas-architecture" + }, + { + "slug": "mcp-gateway-proxy", + "title": "MCP Gateway Proxy Architecture", + "repoPath": "security/devops/mcp-gateway-proxy" + } + ] + }, + "compliance": { + "label": "Compliance", + "count": 13, + "templates": [ + { + "slug": "audit-trail-workflow", + "title": "Audit Trail Workflow", + "repoPath": "compliance/patterns/audit-trail-workflow" + }, + { + "slug": "consent-management-workflow", + "title": "Consent Management Workflow", + "repoPath": "compliance/business-operations/consent-management-workflow" + }, + { + "slug": "cycle-counting-workflow", + "title": "Cycle Counting Workflow", + "repoPath": "compliance/logistics/cycle-counting-workflow" + }, + { + "slug": "data-export-workflow", + "title": "Data Export Workflow", + "repoPath": "compliance/business-operations/data-export-workflow" + }, + { + "slug": "event-sourcing-workflow", + "title": "Event Sourcing Workflow", + "repoPath": "compliance/patterns/event-sourcing-workflow" + }, + { + "slug": "financial-reporting-workflow", + "title": "Financial Reporting Workflow", + "repoPath": "compliance/finance/financial-reporting-workflow" + }, + { + "slug": "fleet-maintenance-workflow", + "title": "Fleet Maintenance Workflow", + "repoPath": "compliance/logistics/fleet-maintenance-workflow" + }, + { + "slug": "gdpr-deletion-workflow", + "title": "Gdpr Deletion Workflow", + "repoPath": "compliance/business-operations/gdpr-deletion-workflow" + }, + { + "slug": "internal-controls-workflow", + "title": "Internal Controls Workflow", + "repoPath": "compliance/finance/internal-controls-workflow" + }, + { + "slug": "payroll-processing-workflow", + "title": "Payroll Processing Workflow", + "repoPath": "compliance/finance/payroll-processing-workflow" + }, + { + "slug": "tax-filing-workflow", + "title": "Tax Filing Workflow", + "repoPath": "compliance/finance/tax-filing-workflow" + }, + { + "slug": "training-enrollment-workflow", + "title": "Training Enrollment Workflow", + "repoPath": "compliance/hr/training-enrollment-workflow" + }, + { + "slug": "yearly-audit-workflow", + "title": "Yearly Audit Workflow", + "repoPath": "compliance/finance/yearly-audit-workflow" + } + ] + }, + "delivery": { + "label": "Delivery & DevOps", + "count": 15, + "templates": [ + { + "slug": "backup-restore-workflow", + "title": "Backup Restore Workflow", + "repoPath": "delivery/devops/backup-restore-workflow" + }, + { + "slug": "blue-green-deploy-workflow", + "title": "Blue Green Deploy Workflow", + "repoPath": "delivery/patterns/blue-green-deploy-workflow" + }, + { + "slug": "ci-cd-pipeline-workflow", + "title": "Ci Cd Pipeline Workflow", + "repoPath": "delivery/devops/ci-cd-pipeline-workflow" + }, + { + "slug": "infrastructure-provisioning-workflow", + "title": "Infrastructure Provisioning Workflow", + "repoPath": "delivery/devops/infrastructure-provisioning-workflow" + }, + { + "slug": "load-testing-workflow", + "title": "Load Testing Workflow", + "repoPath": "delivery/devops/load-testing-workflow" + }, + { + "slug": "saga-pattern-workflow", + "title": "Saga Pattern Workflow", + "repoPath": "delivery/patterns/saga-pattern-workflow" + }, + { + "slug": "microservices-strangler-fig-migration", + "title": "Microservices Strangler Fig Migration Architecture", + "repoPath": "delivery/architecture/microservices-strangler-fig-migration" + }, + { + "slug": "event-driven-event-streaming-pipeline-architecture", + "title": "Event-Driven Streaming Pipeline Architecture", + "repoPath": "delivery/architecture/event-driven-event-streaming-pipeline-architecture" + }, + { + "slug": "serverless-data-pipeline-architecture", + "title": "Serverless Data Pipeline Architecture", + "repoPath": "delivery/architecture/serverless-data-pipeline-architecture" + }, + { + "slug": "saga-orchestration-pattern-architecture", + "title": "Saga Orchestration Pattern Architecture", + "repoPath": "delivery/architecture/saga-orchestration-pattern-architecture" + }, + { + "slug": "gitops-deployment-architecture", + "title": "GitOps Deployment Architecture", + "repoPath": "delivery/architecture/gitops-deployment-architecture" + }, + { + "slug": "ai-native-sequential-pipeline-architecture", + "title": "AI-Native Sequential Pipeline Architecture", + "repoPath": "delivery/architecture/ai-native-sequential-pipeline-architecture" + }, + { + "slug": "ai-native-parallel-fan-out-architecture", + "title": "AI-Native Parallel Fan-Out Architecture", + "repoPath": "delivery/architecture/ai-native-parallel-fan-out-architecture" + }, + { + "slug": "agentic-sequential-pipeline", + "title": "Agentic Sequential Pipeline Architecture", + "repoPath": "delivery/architecture/agentic-sequential-pipeline" + }, + { + "slug": "ai-orchestration-sequential-pipeline", + "title": "AI Orchestration - Sequential Pipeline", + "repoPath": "delivery/architecture/ai-orchestration-sequential-pipeline" + } + ] + }, + "support": { + "label": "Support", + "count": 1, + "templates": [ + { + "slug": "knowledge-base-workflow", + "title": "Knowledge Base Workflow", + "repoPath": "support/business-operations/knowledge-base-workflow" + } + ] + }, + "agentic": { + "label": "Agentic Teams", + "count": 15, + "templates": [ + { + "slug": "ai-native-single-agent-architecture", + "title": "AI-Native Single Agent Architecture", + "repoPath": "agentic/architecture/ai-native-single-agent-architecture" + }, + { + "slug": "ai-native-orchestrator-worker-architecture", + "title": "AI-Native Orchestrator-Worker Architecture", + "repoPath": "agentic/architecture/ai-native-orchestrator-worker-architecture" + }, + { + "slug": "ai-native-hierarchical-architecture", + "title": "AI-Native Hierarchical Architecture", + "repoPath": "agentic/architecture/ai-native-hierarchical-architecture" + }, + { + "slug": "ai-native-event-driven-kafka-architecture", + "title": "AI-Native Event-Driven Kafka Architecture", + "repoPath": "agentic/architecture/ai-native-event-driven-kafka-architecture" + }, + { + "slug": "ai-native-generator-critic-architecture", + "title": "AI-Native Generator-Critic Architecture", + "repoPath": "agentic/architecture/ai-native-generator-critic-architecture" + }, + { + "slug": "agentic-supervisor-worker", + "title": "Agentic Supervisor-Worker Architecture", + "repoPath": "agentic/architecture/agentic-supervisor-worker" + }, + { + "slug": "agentic-swarm", + "title": "Agentic Swarm Architecture", + "repoPath": "agentic/architecture/agentic-swarm" + }, + { + "slug": "agentic-hierarchical", + "title": "Agentic Hierarchical Architecture", + "repoPath": "agentic/architecture/agentic-hierarchical" + }, + { + "slug": "agentic-team-of-rivals", + "title": "Agentic Team of Rivals Architecture", + "repoPath": "agentic/architecture/agentic-team-of-rivals" + }, + { + "slug": "ai-orchestration-orchestrator-worker", + "title": "AI Orchestration - Orchestrator-Worker", + "repoPath": "agentic/architecture/ai-orchestration-orchestrator-worker" + }, + { + "slug": "ai-orchestration-hierarchical", + "title": "AI Orchestration - Hierarchical (Org Chart)", + "repoPath": "agentic/architecture/ai-orchestration-hierarchical" + }, + { + "slug": "ai-orchestration-parallel-fan-out", + "title": "AI Orchestration - Parallel Fan-Out (Map-Reduce)", + "repoPath": "agentic/architecture/ai-orchestration-parallel-fan-out" + }, + { + "slug": "ai-orchestration-competitive-generator-critic", + "title": "AI Orchestration - Competitive Generator-Critic", + "repoPath": "agentic/architecture/ai-orchestration-competitive-generator-critic" + }, + { + "slug": "mcp-agent-mesh", + "title": "MCP Agent Mesh Architecture", + "repoPath": "agentic/devops/mcp-agent-mesh" + }, + { + "slug": "context-shared-memory", + "title": "Context Management - Shared Memory", + "repoPath": "agentic/architecture/context-shared-memory" + } + ] + }, + "ai-orchestration": { + "label": "AI Orchestration", + "count": 6, + "templates": [ + { + "slug": "fan-out-fan-in-workflow", + "title": "Fan Out Fan In Workflow", + "repoPath": "ai-orchestration/patterns/fan-out-fan-in-workflow" + }, + { + "slug": "saga-distributed-transaction-architecture", + "title": "Saga Distributed Transaction Architecture", + "repoPath": "ai-orchestration/architecture/saga-distributed-transaction-architecture" + }, + { + "slug": "saga-travel-booking-architecture", + "title": "Saga Travel Booking Architecture", + "repoPath": "ai-orchestration/architecture/saga-travel-booking-architecture" + }, + { + "slug": "kubernetes-container-orchestration-architecture", + "title": "Kubernetes Container Orchestration Architecture", + "repoPath": "ai-orchestration/architecture/kubernetes-container-orchestration-architecture" + }, + { + "slug": "ai-orchestration-single-agent", + "title": "AI Orchestration - Single Agent (Monolith)", + "repoPath": "ai-orchestration/architecture/ai-orchestration-single-agent" + }, + { + "slug": "ai-orchestration-event-driven-mesh", + "title": "AI Orchestration - Event-Driven Mesh (Kafka-First)", + "repoPath": "ai-orchestration/architecture/ai-orchestration-event-driven-mesh" + } + ] + }, + "mcp": { + "label": "MCP Architecture", + "count": 10, + "templates": [ + { + "slug": "circuit-breaker-workflow", + "title": "Circuit Breaker Workflow", + "repoPath": "mcp/patterns/circuit-breaker-workflow" + }, + { + "slug": "microservices-service-mesh-architecture", + "title": "Microservices Service Mesh Architecture", + "repoPath": "mcp/architecture/microservices-service-mesh-architecture" + }, + { + "slug": "microservices-sidecar-pattern-architecture", + "title": "Microservices Sidecar Pattern Architecture", + "repoPath": "mcp/architecture/microservices-sidecar-pattern-architecture" + }, + { + "slug": "serverless-api-backend-architecture", + "title": "Serverless API Backend Architecture", + "repoPath": "mcp/architecture/serverless-api-backend-architecture" + }, + { + "slug": "circuit-breaker-resilience-architecture", + "title": "Circuit Breaker Resilience Architecture", + "repoPath": "mcp/architecture/circuit-breaker-resilience-architecture" + }, + { + "slug": "ambassador-pattern-architecture", + "title": "Ambassador Pattern Architecture", + "repoPath": "mcp/architecture/ambassador-pattern-architecture" + }, + { + "slug": "graphql-federation-architecture", + "title": "GraphQL Federation Architecture", + "repoPath": "mcp/architecture/graphql-federation-architecture" + }, + { + "slug": "mcp-direct-connect", + "title": "MCP Direct Connect Architecture", + "repoPath": "mcp/devops/mcp-direct-connect" + }, + { + "slug": "mcp-circuit-breaker", + "title": "MCP Circuit Breaker Architecture", + "repoPath": "mcp/devops/mcp-circuit-breaker" + }, + { + "slug": "mcp-context-proxy", + "title": "MCP Context Proxy Architecture", + "repoPath": "mcp/devops/mcp-context-proxy" + } + ] + }, + "context-management": { + "label": "Context Management", + "count": 6, + "templates": [ + { + "slug": "context-session-memory", + "title": "Context Management - Session Memory", + "repoPath": "context-management/architecture/context-session-memory" + }, + { + "slug": "context-rolling-summary-memory", + "title": "Context Management - Rolling Summary Memory", + "repoPath": "context-management/architecture/context-rolling-summary-memory" + }, + { + "slug": "context-profile-memory", + "title": "Context Management - Profile Memory", + "repoPath": "context-management/architecture/context-profile-memory" + }, + { + "slug": "context-semantic-memory", + "title": "Context Management - Semantic Memory", + "repoPath": "context-management/architecture/context-semantic-memory" + }, + { + "slug": "context-episodic-memory", + "title": "Context Management - Episodic Memory", + "repoPath": "context-management/architecture/context-episodic-memory" + }, + { + "slug": "context-hybrid-retrieval-memory", + "title": "Context Management - Hybrid Retrieval Memory", + "repoPath": "context-management/architecture/context-hybrid-retrieval-memory" + } + ] + }, + "uncategorized": { + "label": "Uncategorized", + "count": 106, + "templates": [ + { + "slug": "a-b-testing-workflow", + "title": "A B Testing Workflow", + "repoPath": "uncategorized/patterns/a-b-testing-workflow" + }, + { + "slug": "background-check-workflow", + "title": "Background Check Workflow", + "repoPath": "uncategorized/hr/background-check-workflow" + }, + { + "slug": "bank-reconciliation-workflow", + "title": "Bank Reconciliation Workflow", + "repoPath": "uncategorized/finance/bank-reconciliation-workflow" + }, + { + "slug": "batch-processing-workflow", + "title": "Batch Processing Workflow", + "repoPath": "uncategorized/patterns/batch-processing-workflow" + }, + { + "slug": "bonus-allocation-workflow", + "title": "Bonus Allocation Workflow", + "repoPath": "uncategorized/hr/bonus-allocation-workflow" + }, + { + "slug": "cache-aside-workflow", + "title": "Cache Aside Workflow", + "repoPath": "uncategorized/patterns/cache-aside-workflow" + }, + { + "slug": "callback-pattern-workflow", + "title": "Callback Pattern Workflow", + "repoPath": "uncategorized/patterns/callback-pattern-workflow" + }, + { + "slug": "candidate-rejection-workflow", + "title": "Candidate Rejection Workflow", + "repoPath": "uncategorized/hr/candidate-rejection-workflow" + }, + { + "slug": "carrier-selection-workflow", + "title": "Carrier Selection Workflow", + "repoPath": "uncategorized/logistics/carrier-selection-workflow" + }, + { + "slug": "cash-flow-forecast-workflow", + "title": "Cash Flow Forecast Workflow", + "repoPath": "uncategorized/finance/cash-flow-forecast-workflow" + }, + { + "slug": "chaos-engineering-workflow", + "title": "Chaos Engineering Workflow", + "repoPath": "uncategorized/devops/chaos-engineering-workflow" + }, + { + "slug": "claim-check-workflow", + "title": "Claim Check Workflow", + "repoPath": "uncategorized/patterns/claim-check-workflow" + }, + { + "slug": "cohort-analysis-workflow", + "title": "Cohort Analysis Workflow", + "repoPath": "uncategorized/business-operations/cohort-analysis-workflow" + }, + { + "slug": "community-moderation-workflow", + "title": "Community Moderation Workflow", + "repoPath": "uncategorized/business-operations/community-moderation-workflow" + }, + { + "slug": "compensation-transaction-workflow", + "title": "Compensation Transaction Workflow", + "repoPath": "uncategorized/patterns/compensation-transaction-workflow" + }, + { + "slug": "container-loading-workflow", + "title": "Container Loading Workflow", + "repoPath": "uncategorized/logistics/container-loading-workflow" + }, + { + "slug": "content-enricher-workflow", + "title": "Content Enricher Workflow", + "repoPath": "uncategorized/patterns/content-enricher-workflow" + }, + { + "slug": "cost-center-workflow", + "title": "Cost Center Workflow", + "repoPath": "uncategorized/finance/cost-center-workflow" + }, + { + "slug": "cqrs-workflow", + "title": "Cqrs Workflow", + "repoPath": "uncategorized/patterns/cqrs-workflow" + }, + { + "slug": "credit-control-workflow", + "title": "Credit Control Workflow", + "repoPath": "uncategorized/finance/credit-control-workflow" + }, + { + "slug": "cross-docking-workflow", + "title": "Cross Docking Workflow", + "repoPath": "uncategorized/logistics/cross-docking-workflow" + }, + { + "slug": "crud-user-browser-server-workflow", + "title": "Crud User Browser Server Workflow", + "repoPath": "uncategorized/patterns/crud-user-browser-server-workflow" + }, + { + "slug": "customs-clearance-workflow", + "title": "Customs Clearance Workflow", + "repoPath": "uncategorized/logistics/customs-clearance-workflow" + }, + { + "slug": "damaged-goods-workflow", + "title": "Damaged Goods Workflow", + "repoPath": "uncategorized/logistics/damaged-goods-workflow" + }, + { + "slug": "dead-letter-queue-workflow", + "title": "Dead Letter Queue Workflow", + "repoPath": "uncategorized/patterns/dead-letter-queue-workflow" + }, + { + "slug": "decision-diamond-workflow", + "title": "Decision Diamond Workflow", + "repoPath": "uncategorized/patterns/decision-diamond-workflow" + }, + { + "slug": "delivery-confirmation-workflow", + "title": "Delivery Confirmation Workflow", + "repoPath": "uncategorized/logistics/delivery-confirmation-workflow" + }, + { + "slug": "diversity-initiative-workflow", + "title": "Diversity Initiative Workflow", + "repoPath": "uncategorized/hr/diversity-initiative-workflow" + }, + { + "slug": "email-campaign-workflow", + "title": "Email Campaign Workflow", + "repoPath": "uncategorized/business-operations/email-campaign-workflow" + }, + { + "slug": "employee-engagement-workflow", + "title": "Employee Engagement Workflow", + "repoPath": "uncategorized/hr/employee-engagement-workflow" + }, + { + "slug": "enricher-workflow", + "title": "Enricher Workflow", + "repoPath": "uncategorized/patterns/enricher-workflow" + }, + { + "slug": "error-retry-loop-workflow", + "title": "Error Retry Loop Workflow", + "repoPath": "uncategorized/patterns/error-retry-loop-workflow" + }, + { + "slug": "event-driven-workflow", + "title": "Event Driven Workflow", + "repoPath": "uncategorized/patterns/event-driven-workflow" + }, + { + "slug": "expense-allocation-workflow", + "title": "Expense Allocation Workflow", + "repoPath": "uncategorized/finance/expense-allocation-workflow" + }, + { + "slug": "feature-toggle-workflow", + "title": "Feature Toggle Workflow", + "repoPath": "uncategorized/patterns/feature-toggle-workflow" + }, + { + "slug": "filter-workflow", + "title": "Filter Workflow", + "repoPath": "uncategorized/patterns/filter-workflow" + }, + { + "slug": "fixed-assets-workflow", + "title": "Fixed Assets Workflow", + "repoPath": "uncategorized/finance/fixed-assets-workflow" + }, + { + "slug": "idempotent-consumer-workflow", + "title": "Idempotent Consumer Workflow", + "repoPath": "uncategorized/patterns/idempotent-consumer-workflow" + }, + { + "slug": "in-app-message-workflow", + "title": "In App Message Workflow", + "repoPath": "uncategorized/business-operations/in-app-message-workflow" + }, + { + "slug": "internship-program-workflow", + "title": "Internship Program Workflow", + "repoPath": "uncategorized/hr/internship-program-workflow" + }, + { + "slug": "interview-process-workflow", + "title": "Interview Process Workflow", + "repoPath": "uncategorized/hr/interview-process-workflow" + }, + { + "slug": "inventory-receipt-workflow", + "title": "Inventory Receipt Workflow", + "repoPath": "uncategorized/logistics/inventory-receipt-workflow" + }, + { + "slug": "job-posting-workflow", + "title": "Job Posting Workflow", + "repoPath": "uncategorized/hr/job-posting-workflow" + }, + { + "slug": "kitting-process-workflow", + "title": "Kitting Process Workflow", + "repoPath": "uncategorized/logistics/kitting-process-workflow" + }, + { + "slug": "last-mile-delivery-workflow", + "title": "Last Mile Delivery Workflow", + "repoPath": "uncategorized/logistics/last-mile-delivery-workflow" + }, + { + "slug": "materialized-view-workflow", + "title": "Materialized View Workflow", + "repoPath": "uncategorized/patterns/materialized-view-workflow" + }, + { + "slug": "message-queue-workflow", + "title": "Message Queue Workflow", + "repoPath": "uncategorized/patterns/message-queue-workflow" + }, + { + "slug": "monthly-close-workflow", + "title": "Monthly Close Workflow", + "repoPath": "uncategorized/finance/monthly-close-workflow" + }, + { + "slug": "nested-decisions-workflow", + "title": "Nested Decisions Workflow", + "repoPath": "uncategorized/patterns/nested-decisions-workflow" + }, + { + "slug": "normalizer-workflow", + "title": "Normalizer Workflow", + "repoPath": "uncategorized/patterns/normalizer-workflow" + }, + { + "slug": "notification-pattern-workflow", + "title": "Notification Pattern Workflow", + "repoPath": "uncategorized/patterns/notification-pattern-workflow" + }, + { + "slug": "packing-process-workflow", + "title": "Packing Process Workflow", + "repoPath": "uncategorized/logistics/packing-process-workflow" + }, + { + "slug": "parallel-execution-workflow", + "title": "Parallel Execution Workflow", + "repoPath": "uncategorized/patterns/parallel-execution-workflow" + }, + { + "slug": "personalization-engine-workflow", + "title": "Personalization Engine Workflow", + "repoPath": "uncategorized/business-operations/personalization-engine-workflow" + }, + { + "slug": "picking-process-workflow", + "title": "Picking Process Workflow", + "repoPath": "uncategorized/logistics/picking-process-workflow" + }, + { + "slug": "polling-pattern-workflow", + "title": "Polling Pattern Workflow", + "repoPath": "uncategorized/patterns/polling-pattern-workflow" + }, + { + "slug": "process-manager-workflow", + "title": "Process Manager Workflow", + "repoPath": "uncategorized/patterns/process-manager-workflow" + }, + { + "slug": "procurement-card-workflow", + "title": "Procurement Card Workflow", + "repoPath": "uncategorized/finance/procurement-card-workflow" + }, + { + "slug": "promotion-process-workflow", + "title": "Promotion Process Workflow", + "repoPath": "uncategorized/hr/promotion-process-workflow" + }, + { + "slug": "pub-sub-workflow", + "title": "Pub Sub Workflow", + "repoPath": "uncategorized/patterns/pub-sub-workflow" + }, + { + "slug": "push-notification-workflow", + "title": "Push Notification Workflow", + "repoPath": "uncategorized/business-operations/push-notification-workflow" + }, + { + "slug": "put-away-process-workflow", + "title": "Put Away Process Workflow", + "repoPath": "uncategorized/logistics/put-away-process-workflow" + }, + { + "slug": "quality-inspection-workflow", + "title": "Quality Inspection Workflow", + "repoPath": "uncategorized/logistics/quality-inspection-workflow" + }, + { + "slug": "rate-limiter-workflow", + "title": "Rate Limiter Workflow", + "repoPath": "uncategorized/patterns/rate-limiter-workflow" + }, + { + "slug": "reference-check-workflow", + "title": "Reference Check Workflow", + "repoPath": "uncategorized/hr/reference-check-workflow" + }, + { + "slug": "referral-program-workflow", + "title": "Referral Program Workflow", + "repoPath": "uncategorized/business-operations/referral-program-workflow" + }, + { + "slug": "relocation-assistance-workflow", + "title": "Relocation Assistance Workflow", + "repoPath": "uncategorized/hr/relocation-assistance-workflow" + }, + { + "slug": "reorder-process-workflow", + "title": "Reorder Process Workflow", + "repoPath": "uncategorized/logistics/reorder-process-workflow" + }, + { + "slug": "request-reply-workflow", + "title": "Request Reply Workflow", + "repoPath": "uncategorized/patterns/request-reply-workflow" + }, + { + "slug": "retry-with-backoff-workflow", + "title": "Retry With Backoff Workflow", + "repoPath": "uncategorized/patterns/retry-with-backoff-workflow" + }, + { + "slug": "reverse-logistics-workflow", + "title": "Reverse Logistics Workflow", + "repoPath": "uncategorized/logistics/reverse-logistics-workflow" + }, + { + "slug": "router-workflow", + "title": "Router Workflow", + "repoPath": "uncategorized/patterns/router-workflow" + }, + { + "slug": "search-optimization-workflow", + "title": "Search Optimization Workflow", + "repoPath": "uncategorized/business-operations/search-optimization-workflow" + }, + { + "slug": "snapshot-pattern-workflow", + "title": "Snapshot Pattern Workflow", + "repoPath": "uncategorized/patterns/snapshot-pattern-workflow" + }, + { + "slug": "state-machine-workflow", + "title": "State Machine Workflow", + "repoPath": "uncategorized/patterns/state-machine-workflow" + }, + { + "slug": "strangler-fig-workflow", + "title": "Strangler Fig Workflow", + "repoPath": "uncategorized/patterns/strangler-fig-workflow" + }, + { + "slug": "timeout-pattern-workflow", + "title": "Timeout Pattern Workflow", + "repoPath": "uncategorized/patterns/timeout-pattern-workflow" + }, + { + "slug": "transactional-outbox-workflow", + "title": "Transactional Outbox Workflow", + "repoPath": "uncategorized/patterns/transactional-outbox-workflow" + }, + { + "slug": "transform-workflow", + "title": "Transform Workflow", + "repoPath": "uncategorized/patterns/transform-workflow" + }, + { + "slug": "treasury-management-workflow", + "title": "Treasury Management Workflow", + "repoPath": "uncategorized/finance/treasury-management-workflow" + }, + { + "slug": "user-segmentation-workflow", + "title": "User Segmentation Workflow", + "repoPath": "uncategorized/business-operations/user-segmentation-workflow" + }, + { + "slug": "validator-workflow", + "title": "Validator Workflow", + "repoPath": "uncategorized/patterns/validator-workflow" + }, + { + "slug": "webhook-integration-workflow", + "title": "Webhook Integration Workflow", + "repoPath": "uncategorized/business-operations/webhook-integration-workflow" + }, + { + "slug": "webhook-pattern-workflow", + "title": "Webhook Pattern Workflow", + "repoPath": "uncategorized/patterns/webhook-pattern-workflow" + }, + { + "slug": "microservices-database-per-service-architecture", + "title": "Microservices Database-Per-Service Architecture", + "repoPath": "uncategorized/architecture/microservices-database-per-service-architecture" + }, + { + "slug": "microservices-decomposition-by-business-capability", + "title": "Microservices Decomposition by Business Capability", + "repoPath": "uncategorized/architecture/microservices-decomposition-by-business-capability" + }, + { + "slug": "microservices-backend-for-frontend-architecture", + "title": "Microservices Backend-for-Frontend (BFF) Architecture", + "repoPath": "uncategorized/architecture/microservices-backend-for-frontend-architecture" + }, + { + "slug": "event-driven-publish-subscribe-architecture", + "title": "Event-Driven Publish-Subscribe Architecture", + "repoPath": "uncategorized/architecture/event-driven-publish-subscribe-architecture" + }, + { + "slug": "event-driven-event-sourcing-architecture", + "title": "Event-Driven Event Sourcing Architecture", + "repoPath": "uncategorized/architecture/event-driven-event-sourcing-architecture" + }, + { + "slug": "event-driven-cqrs-with-event-store-architecture", + "title": "Event-Driven CQRS with Event Store Architecture", + "repoPath": "uncategorized/architecture/event-driven-cqrs-with-event-store-architecture" + }, + { + "slug": "event-driven-choreography-architecture", + "title": "Event-Driven Choreography Architecture", + "repoPath": "uncategorized/architecture/event-driven-choreography-architecture" + }, + { + "slug": "event-driven-cdc-change-data-capture-architecture", + "title": "Event-Driven CDC (Change Data Capture) Architecture", + "repoPath": "uncategorized/architecture/event-driven-cdc-change-data-capture-architecture" + }, + { + "slug": "cqrs-read-write-separation-architecture", + "title": "CQRS Read-Write Separation Architecture", + "repoPath": "uncategorized/architecture/cqrs-read-write-separation-architecture" + }, + { + "slug": "cqrs-materialized-view-architecture", + "title": "CQRS Materialized View Architecture", + "repoPath": "uncategorized/architecture/cqrs-materialized-view-architecture" + }, + { + "slug": "cqrs-task-based-ui-architecture", + "title": "CQRS Task-Based UI Architecture", + "repoPath": "uncategorized/architecture/cqrs-task-based-ui-architecture" + }, + { + "slug": "serverless-event-processing-architecture", + "title": "Serverless Event Processing Architecture", + "repoPath": "uncategorized/architecture/serverless-event-processing-architecture" + }, + { + "slug": "saga-choreography-pattern-architecture", + "title": "Saga Choreography Pattern Architecture", + "repoPath": "uncategorized/architecture/saga-choreography-pattern-architecture" + }, + { + "slug": "retry-with-exponential-backoff-architecture", + "title": "Retry with Exponential Backoff Architecture", + "repoPath": "uncategorized/architecture/retry-with-exponential-backoff-architecture" + }, + { + "slug": "rate-limiter-architecture", + "title": "Rate Limiter Architecture", + "repoPath": "uncategorized/architecture/rate-limiter-architecture" + }, + { + "slug": "hexagonal-ports-adapters-architecture", + "title": "Hexagonal (Ports and Adapters) Architecture", + "repoPath": "uncategorized/architecture/hexagonal-ports-adapters-architecture" + }, + { + "slug": "clean-architecture-layers", + "title": "Clean Architecture Layers", + "repoPath": "uncategorized/architecture/clean-architecture-layers" + }, + { + "slug": "domain-driven-design-bounded-contexts-architecture", + "title": "Domain-Driven Design Bounded Contexts Architecture", + "repoPath": "uncategorized/architecture/domain-driven-design-bounded-contexts-architecture" + }, + { + "slug": "outbox-pattern-reliable-messaging-architecture", + "title": "Outbox Pattern for Reliable Messaging Architecture", + "repoPath": "uncategorized/architecture/outbox-pattern-reliable-messaging-architecture" + }, + { + "slug": "data-mesh-architecture", + "title": "Data Mesh Architecture", + "repoPath": "uncategorized/architecture/data-mesh-architecture" + }, + { + "slug": "observability-three-pillars-architecture", + "title": "Observability Three Pillars Architecture", + "repoPath": "uncategorized/architecture/observability-three-pillars-architecture" + }, + { + "slug": "event-driven-notification-hub-architecture", + "title": "Event-Driven Notification Hub Architecture", + "repoPath": "uncategorized/architecture/event-driven-notification-hub-architecture" + } + ] + } + } +}