Designer

Draw how your software fits together and how its flows run: architecture designs with a shared catalog of components, and workflows you can walk through step by step.

• Draw your first architecture - Start from a ready design, put components on the canvas, connect them, and keep, check and export the result.
• Bring in a diagram, an API or plain words - Turn a diagram file, an API, a picture or a few sentences into a design, or merge one into the design you have open.
• Bring in BPMN, C4, docker-compose or Gherkin files - Turn a BPMN process, a Structurizr or C4-PlantUML model, a docker-compose file or a Gherkin feature into a design.
• Make a design from a photo of a diagram - Choose a photo of a whiteboard or a screenshot of a diagram, and let AI read it into a design you check first.
• Bring in a Figma prototype - Turn the frames and flows of a Figma prototype into a workflow, where your installation has turned this on.
• Design a workflow - Describe a flow step by step: who does what, what they enter and how it is checked, the decisions and every way it can fail.
• Draw a screen - Draw a screen of a component as a simple page of boxes, put elements inside each other, say what each button does, and let AI add what you describe.
• Make a clickable prototype and share it - Link your drawn screens so a tap moves from one to the next, play them, and send a link for approval.
• Line up, reuse and inspect what you draw - Align and space parts, stack them, reuse components, step back through your changes and copy what a developer needs.
• Switch between the simple and the full editor - Work on a feature's design with only the drawing and one next step, and switch to the full editor when you need every menu.
• Turn a workflow into cards and tests - Create the plan makes an epic and cards on a board, saved requests and a test suite in API Tester, and a build brief for each card - all from one workflow.
• Build a whole feature with coding agents - Give a workflow's cards to your own coding agents in building order; each card opens when the steps before it are merged and verified.
• See which steps are built and tested - Switch on Coverage to see, on every step, where its card stands and what its tests say - and find designs where something fails.
• Find where the built API differs from the workflow - Compare a workflow's API calls with the built API, then update the design, mark a difference as intended, or file a bug.
• Ask for sign-off on a design - Ask the people who manage a design to approve a version, decide when you are asked, and send one outside person an approval link.
• Change an approved design through a Change - Propose a Change to a design that has an approved version, approve or decline it, build it, and see every Change in one list or on a calendar.
• Prove a feature works and export its trace - Make a frozen proof of a feature - steps verified, cards and sign-offs - share it by link, and read its full trace on screen or download it as Excel or Word.
• See who a design change reaches and tell them - Before you sync the plan, see which cards, test cases and endpoints a change reaches, who owns them, and announce it.
• Ask a question about a step and keep the decision - Ask a named person about a step, answer with words or a link, and accept the answer as a decision kept beside the step and in Notes.
• Discuss a design with everyone on it - Every design has one discussion that everyone who can open it reads, also from the cards and endpoints the design planned.
• Comment on a design - Pin a comment to a design, a part, a step or a connection, reply in a thread, mention people and resolve it when it is settled.
• Plan a meeting about a feature - Put a Planner event about a design in the calendar, with an agenda written from its open questions, changes and failing steps.
• Walk through a workflow and its journeys - Follow a flow by hand, choosing a branch at every decision, and see every journey from start to end.
• Keep references current - See which steps refer to a component, a design, a card or a test that changed since they were reviewed, where a design or component is used, and move between linked designs.
• Show one design in several views - Make named views of one design, each showing chosen parts placed as you like, and hide layers on your own screen.
• Find parts and change many at once - Find parts and steps by name, kind, tag, owner, technology, requirement ID or property, then change all matches in one step.
• Add your own fields to parts and steps - Give parts and steps an owner, tags and properties, and define fields every design of your workspace offers.
• Trace requirements to parts and steps - Keep a list of requirement IDs, trace each to the parts and steps that meet it, and import the list from a CSV or Excel file.
• Compare two versions of a design - Put two versions of a design side by side and see which parts and connections were added, removed or changed.
• Present a design - Show a design full screen, view by view and journey by journey, with speaker notes and a laser pointer.
• Save a design as a template - Turn a finished design into a template your organization starts new designs from, and keep it up to date.
• Make a component the page of its service - Link a service's API projects, tests and monitors to its catalog component once, and see its health, open bugs and the designs that use it in one place.
• Set health targets for a service - Say how often a service's monitor checks must pass and how fast they must answer, then watch the room left for failures on the service page and Home.
• Read a service's lessons, owners and evidence - Four reports from a service page: what the service teaches, ownership and who it depends on, change-management evidence, and evidence for an auditor.
• Connect your code to the Designer - Add a code source - the CLI, an upload or a repository - so your designs can be matched to what was really built.
• See how your repositories join on the System map - Draw every repository the organization reads, the services in each and the requests and topics that join them, and see what depends on a service.
• Match an architecture to the running system - Live match compares an architecture with the code readings and what API Tester saw live, gives it a score, and adds what is missing.
• Check an architecture for security risks - The threat model runs fixed checks on an architecture - data crossing a boundary without TLS, a reachable database, a service without sign-in, shared secrets - and turns findings into cards.
• Hold your code to architecture rules - Choose the rules your code must keep, such as "The web never calls a database directly", and read each break with its file and line.
• List the personal data your system keeps - Mark the table columns that hold personal data, then open the record of processing: the tables, the functions that use them and the outside systems the data flows to.
• Turn a workflow into an API test suite - Draft an API suite from a workflow's system steps in one click, so each step reads Verified once its test passes.
• Export a design and its implementation prompt - Export one design or a design with its linked designs as pictures, data and documentation, and build an implementation prompt that says what is verified.
• Export a design as a picture, document or diagram text - Save a design as PNG or SVG, as a PDF, Word or Markdown document, as Mermaid text or as a file to import again.
• Draft UI tests for each journey - Turn the journeys of a workflow into draft tracks in UI Tester, one for each journey, ready to record.