RabbinatixDocs
Sign inGet started

Build behaviour (Flow-Driven Development)

Flow-Driven Development

The method behind Rabbinatix: describe how your software behaves as a flow you can run, prove it with test cases, then turn it into code.

Open Flows in the app

What it is

Flow-Driven Development (FDD) is a way of building software where the behaviour comes first. Before anyone writes code, you describe what happens as a flow: a business process, such as signing in or checking out, that starts in one system and crosses others. Each step of the flow has logic you build from nodes on a canvas. Test data stands in for databases and APIs that don't exist yet. Test cases say what should happen, and you press Run to see whether it does.

The result is a model of how your software works that you can run, test and read. Developers then build against the same model, and Rabbinatix can generate code from it and check that the code behaves the same way.

FDD sits on top of the system map. Your systems and the APIs between them (Systems, APIs and contracts) are the stage; flows and logic are what happens on it. When logic calls another system, it goes through a real API contract, so a contract break shows up in the flow too.

The method, end to end

You don't have to use every step. Small teams often start at step 3. The order below is the one that saves the most rework.

  1. Sketch it. Draw the journey on a whiteboard: steps, questions, screens and the systems involved. Nothing runs yet. Get it reviewed and approved. See Whiteboards.
  2. Write the requirements. One line each, such as "Reject invalid credentials without revealing whether the account exists". See Requirements.
  3. Build the flow. Pick where it starts (an API or a user action). Rabbinatix follows the logic across systems and draws the lanes for you. See Flows.
  4. Build the logic for each step. Connect nodes: check the input, call an API, query a database, branch, return. See Logic.
  5. Add test data and expected results. Test data answers for databases and APIs; expected results describe the answer you expect. See Test data and expected results.
  6. Write test cases. "Valid credentials", "Wrong password", "Missing email". Each one is an acceptance test: an input, the test data to use and the expected result. Link them to your requirements.
  7. Run it and travel in time. Watch the run move through the systems, step back and forward, and inspect the data at every step. See Test cases and runs.
  8. Generate verified code. Read the logic as code, download it, and check it against the test cases you already ran. See Code generation.
  9. Watch it live. Compare what the real systems do with what the flow says they should do. See Real logic and real traffic and Contract watcher.
TipYou can skip the drawing and start from a ready-made flow. The Store has a tested email and password login and registration you can fit to your own systems.

Keys

Every object in FDD has a key: a readable ID that never changes, even when you rename the object. Use keys in tickets, commits, code changes and bug reports. Press Ctrl+K and type a key to open what it names.

ObjectExample key
SystemSYS-AUTH-001
API (provider endpoint)CONTRACT-AUTH-LOGIN-001
WhiteboardWHITEBOARD-001
RequirementREQ-AUTH-001
FlowFLOW-AUTH-LOGIN-001
LogicLOGIC-AUTH-LOGIN-001 (reusable logic: LOGIC-LIB-…)
Step in a logic (node)NODE-AUTH-LOGIN-017
Test dataTEST-DATA-USER-DARIUS-001 (older ones: DATA-BP-…)
Expected resultEXPECTED-LOGIN-SUCCESS-001 (older ones: RESPONSE-BP-…)
Test caseTEST-CASE-AUTH-LOGIN-002
RunRUN-20260928-001

The middle part comes from the system and the object's name. A key never changes: older test data, expected results and test cases keep the key they were given (DATA-BP-…, RESPONSE-BP-…, SCENARIO-…), and mentions, links and search find them by it. The number counts up across the organization or project. Simple view hides keys for people who don't need them.

Who does what

FDD works best when the people who know the business and the people who write code share one model. The built-in roles fit the method like this. Your organization can change them in Members and roles.

RoleTypical work
Project ownerDraws whiteboards, writes requirements, designs flows, test data and test cases, approves flows
DeveloperBuilds and refines logic, links it to APIs, generates and releases the code
QAWrites test data and test cases, runs them, files bugs from failed runs
ViewerReads everything and can do test runs

A flow moves through statuses as the work goes on: Draft, Approved, In development, Implemented and Verified. The status is set by hand, so it says what the team agreed, not what a tool guessed.

How the pieces connect

  • A whiteboard is the sketch. Once published, each shape links to what it became: a system, an API, a flow, logic, a requirement or a ticket.
  • A flow starts at one logic and follows its calls into other systems.
  • Logic belongs to a system (or to none, when it is reusable). Its steps call APIs through their contracts.
  • Test data answers at the edges: databases, queues, external services, other APIs and the flow's input.
  • Test cases bring an input, test data and an expected result together. Each run is stored with the exact versions it used.
  • Requirements count as covered when their test cases pass.
  • Generated code comes from the same logic, and its verification replays the test cases' runs.

Because every link is stored, you can start anywhere and follow the chain: from a failing run back to the requirement, or from an API change forward to the flows it breaks (Change impact).

Where to start

  • New to all of this: follow Quick start, then the step-by-step login example.
  • Have systems already: open Flows, press New flow and pick an existing logic as the start.
  • Want to see a finished one: open the Store and use Try it on a flow.