Documentation
Rabbinatix docs
Rabbinatix is a living map of how your software works: the systems, the API contracts between them, the flows across them and the logic in each step, so developers see what a change touches and what it breaks before it ships. These guides show how to put the code you have on the map, see what a change breaks, and design the next one.
New here? Start with What Rabbinatix is and the quick start.
Getting started
What Rabbinatix is, and your first organization, system, flow and logic.
- What Rabbinatix isRabbinatix is a living map of how your software works: the systems, the API contracts between them, the flows across them and the logic in each step, so developers see what a change touches and what it breaks before it ships.
- Quick startFrom sign-up to a first verified flow: create an organization or project, put two systems on the map, connect them with a checked API, give it logic, and prove it with a test case.
- Organizations and PersonalWhere your work lives. An organization for a team, and your own Personal workspace for yourself; each holds projects. Switch between them, and turn Personal into an organization when others join.
- Your profileYour photo, job title and a few words about you; who may see them; your organizations and projects, chat friends and work in one place; your account, password and data.
- Navigating the appThe sidebar, search and the command palette, page help and Simple view, action menus, notifications, the theme and keyboard shortcuts.
Map your systems
Systems, the APIs between them, the contracts that keep them honest, and how change moves through them.
- SystemsCreate the apps and services you build or depend on, give them owners and tags, and find any system or API again.
- The system mapYour systems and the connections between them on one canvas, coloured by contract health, with a table and a Connections view.
- APIs and contractsDeclare what providers offer and what consumers expect. Rabbinatix pairs them into contracts and checks them field by field.
- Document your APIsSay what each API is for, what every field means and when each answer happens, and let Rabbinatix keep the docs honest: who relies on each field, the flows it is part of, and why it is like this.
- Contract statusesWhat each status means, how one contract colours a connection and a system, how to read a contract, and how to tune the checks.
- Import and exportBring in OpenAPI, Postman, Pact and browser recording (HAR) files, sync again when they change, and export OpenAPI and Pact.
- Change impact and Draft modeSee what an API change would break before anyone feels it, share the drafts for review, and publish them when they are right.
- Versions and releasesRun API versions side by side, read the history and diff of every endpoint, create releases with a suggested version, and check old copies.
- Retiring APIsRetire an API with a shutdown date and a replacement, and follow every consumer until they have all moved off.
- Security checksFind the usual API security mistakes in your design and your code: an API that changes data without sign-in, a password in a response, a token in the URL.
Build behaviour (Flow-Driven Development)
Sketch it, flow it, build the logic, prove it with test cases, and take the code.
- Flow-Driven DevelopmentThe method behind Rabbinatix: describe how your software behaves as a flow you can run, prove it with test cases, then turn it into code.
- WhiteboardsSketch a journey with shapes and arrows, get it reviewed and approved, then turn it into work and track what each shape became.
- Requirements and coverageWrite requirements, link them to flows and test cases, and see which ones your runs prove. Follow any change to the flows it affects.
- FlowsBuild a flow from the logic it starts at, see it cross your systems in lanes, and move it from draft to verified.
- LogicBuild what a system does by connecting nodes on a canvas: endpoint logic for an API, event logic for a user action, and functions you reuse.
- ScreensDesign the pages of a website or app from widgets, like a design file: click them through, put them on whiteboards, and export them as plain HTML and CSS.
- Test data and expected resultsTest data stands in for databases, APIs and inputs that don’t exist yet; expected results describe the result you expect.
- Test cases and runsWrite test cases as acceptance tests, run the flow and watch it move through your systems, step back in time, and compare runs and versions.
- Text stepsRead any logic or flow as text steps, copy or download them, and take it to your AI assistant and back.
- Code generationSee the code for a logic as you build it, take it away as files, and check it returns what the test cases returned.
- Programming languagesWhat works in which programming language: anchors and highlighting in all of them, plus code generation, code impact, API routes, security rules and code snippets.
- The StoreFree, tested flows, logic, system maps and whiteboards: try one on its page, fit it to your systems, and copy it in, or take its code.
- Reusable logic and packagesBuild functions that belong to no system and call them anywhere, add logic packages, and publish your own flows and logic.
Run and observe
Test servers, the real API, environments and deployments, health checks, and the contract watcher in your frontend.
- Test serverEvery system gets a test server URL that answers like its declared endpoints, so frontends can start before the backend exists.
- Send requests to the real APITest APIs sends a request from your browser to a system’s running API and checks the answer against its contract.
- Environments and deploymentsRecord which release of each system runs in each environment, see compatibility per environment, and check a release before you deploy it.
- CI and the APIGate deployments in CI with the safety check and record what you deploy, using an API token and the HTTP API.
- The rabbinatix CLIEvery rabbinatix command: what it does, what it sends, the token it needs and how it ends, for your terminal and your CI.
- Code impact: what a change affectsCheck a code change against the map: a pull request in your pipeline, any two branches or commits, or your AI assistant's own work. Which logic, flows and contracts it reaches, which test cases to run, and whether the map still says what the code does.
- Health checksTell Rabbinatix how to see whether a service is up in each environment. It calls each environment’s health URL while someone has the Connections view open, and shows the service as operational, degraded, down or in maintenance there.
- Report errors from your servicesLet your running services report the errors a health check can't see, such as a failed payment, so the map and the Connections view show which systems are in trouble right now.
- Contract watcherDownload one file, start it in your frontend in development, and every real API call is checked against your contracts.
- Real logic and real trafficRun test cases with every system answering through its real logic, and compare the flows you designed with the calls a running app makes.
Work as a team
The board and tickets, chat, notifications, integrations and public APIs.
- Pages and spacesWrite your project’s knowledge (overviews, decisions, runbooks, how-tos, meeting notes) in spaces, with live links to systems, flows, logic and tickets.
- The board and ticketsTrack work as tickets on one board: types, columns, tags and sprints, mentions that open the exact place, and the planning views.
- Automatic tickets and automationTickets that open and close themselves when a contract breaks, a test case fails or a service goes down, plus request tickets, access tickets and your own automation rules.
- ChatTalk about systems and contracts in channels that know about them: live status cards, Rabbinatix posts when something breaks, threads, and messages that become tickets.
- NotificationsHear about the events that matter to you: in the app or by email, with a level for each kind of event.
- IntegrationsSend contract and ticket events to your own endpoint or an email address with webhooks, and see each delivery and its retries.
- Public APIsPublish an API for other organizations to depend on, subscribe to theirs with real contracts, and see which fields your subscribers rely on.
- Connect your AI assistantConnect the AI assistant in your editor with a key of your own, let it read and draft, and review its drafts before anything changes.
- AI assistant or CLI: which does whatWhere your AI assistant works and where the rabbinatix CLI works, the rules between them, and every feature that touches code.
- Time awayMark when people are away, add public holidays, and pick who covers, so sign-offs and team issues reach someone who is here.
- Sign-off from affected teamsWhen a release changes or breaks the calls other teams make, those teams are asked to sign off before it moves; every answer and every move without one is recorded.
- Releases on the calendarWhat ships when: planned releases, the moves that happened, no-release days, public holidays and who is away, on Calendar.
- CalendarEvery team date in one place: releases, meetings, who's away, and what's due.
- MeetingsSchedule meetings with people of your organization, answer them, get a reminder and join.
- World clock and finding a timeSee the time where your teammates and partners are, whether it is working hours there, and find a meeting time that works across time zones.
- Org chartSee who reports to whom, each person’s position and which department each team is in, and find who to ask about a system.
- Team promisesWhat one team promises another for a system: uptime, response time, notice before breaking changes, how fast a service is fixed, how fast sign-offs are answered — agreed by both, measured by Rabbinatix.
- Team issuesQuality problems one team causes another, raised by a lead or by Rabbinatix, answered by the team they are against, and counted in each team’s health.
Manage your organization
Members and roles, settings, billing, the activity log, your data, and the API.
- ProjectsKeep each client’s or product’s work apart inside one organization: its own systems, flows, board and environments, with the same people, roles and plan.
- Members and rolesInvite people to your organization, give them a role, build your own roles, group people into teams and handle access requests.
- SettingsEvery tab of Settings: your profile and the organization, single sign-on, the uptime commitment and security review, appearance, health checks, roles, tickets, chat and contract policy. Members and teams, Usage and billing, Environments and Trash have their own sidebar entries.
- Plans and billingWhat Free, Standard, Premium and Enterprise include, how to upgrade and pay through Paddle, and what happens when you cancel, a payment fails or you move down.
- TrashDeleted systems, APIs, flows, logic, whiteboards, pages and spaces wait in the trash for 30 days: what goes in, who sees it, and how to restore it or delete it for good.
- Activity logThe record of who changed what in your organization, and when: what it records, how to filter it and how to export it.
- Data and privacyExport an organization or project, delete one or your account, and what personal data Rabbinatix keeps.
- API and tokensCreate API tokens for CI and scripts, choose their scopes, and call the REST API at /api/v1.
- AccessibilityHow Rabbinatix supports WCAG 2.2 AA: using it by keyboard (canvases, whiteboards and Inspect too), Simple view, reduced motion, the text alternatives to canvases, and how to report a problem.
Reference
- Logic editor referenceEvery panel and tab of the logic editor, and a guide to every node.
- Step-by-step examplesEvery click and value to build a login flow, a system map, logic and a whiteboard.
- AI assistant referenceConnect the assistant in your editor, review its drafts, and the guide it reads.
- Flow Pseudocode (FPC)Text steps, the plain-text form logic reads as: reference, cheat sheet, grammar and a validator.
- Concepts and termsEvery word Rabbinatix uses, in plain words.
