We believe great software
starts with great architecture.
BackArch is the collaborative backend architecture platform built for engineers who take their systems seriously. We combine a visual canvas, constraint-aware AI, real-time multi-cloud pricing, and automated health scoring into a single workspace — so your team spends less time arguing in spreadsheets and more time building things that scale.
Our Mission
Make world-class backend architecture accessible to every engineering team — not just those with a principal architect on staff. BackArch gives your team the knowledge, guardrails, and tooling to design systems that actually hold up in production.
Our Vision
A future where every deployment decision is made with full awareness of its cost, resilience, and architectural merit — captured in a living document your whole team can understand, evolve, and trust. Architecture as a first-class engineering artifact.
Who We Build For
Backend engineers designing new systems or evolving existing ones. Platform teams who own infrastructure decisions. CTOs and tech leads who need architecture to be legible to the whole org — not just in someone's head.
“The architecture is the product. Everything else is implementation. We built BackArch because we watched great engineers ship poorly-designed systems not from lack of skill, but lack of the right tools to think, collaborate, and validate — before the code got written.”
Everything BackArch does,
in full detail.
This is the reference guide. Every feature, every interaction, every design decision explained so you can use BackArch to its full potential from day one.
Visual Architecture Canvas
The canvas is your primary workspace. It's a fully interactive drag-and-drop environment built on top of a flow graph engine, purpose-built for backend system design. Every element you place on the canvas represents a real infrastructure component — not just a box with a label.
The palette ships with everything you need: API Gateways (Kong, AWS API Gateway, NGINX), compute (EC2, Lambda, ECS, Cloud Run, Azure Functions), databases (PostgreSQL, MySQL, MongoDB, DynamoDB, Firestore, CosmosDB), caches (Redis, Memcached, ElastiCache), queues and streams (SQS, SNS, Kafka, Pub/Sub, RabbitMQ, EventBridge), storage (S3, GCS, Azure Blob), CDNs, load balancers, vector databases, search engines, and observability components. Every component is pre-configured with its canonical connection semantics.
Every connection between components carries semantic meaning. BackArch knows that a REST call is different from a queue publication, a database read is different from a database write, and a streaming connection has different failure modes than an RPC. This typing is what lets the health score and AI reason about your architecture — not just see a graph.
Changes are auto-saved with a 2.5-second debounce — you'll never lose work. Every saved state creates a version entry you can browse in the Version History drawer. Restore any previous state with a single click. Versions are labeled automatically by timestamp and annotated when the AI makes a structural change.
Click any node to open its properties panel. Configure the specific instance type, region, replication factor, storage class, or SKU. These settings flow directly into the live pricing calculator — change an EC2 t3.large to a t3.xlarge and watch your monthly cost update in real time.
The toolbar gives you zoom controls, fit-to-view, select-all, undo/redo, and the ability to toggle between standard mode and constraint-edit mode. A minimap in the corner lets you navigate large architectures without losing context.
Don't start from scratch every time. BackArch ships with pre-built templates for the most common backend topologies — microservices, event-driven, serverless, monolith-to-service migration, and CQRS. Each template is a fully wired, health-scored starting point you can fork and reshape to fit your actual system.
- 1Click any component in the left palette to add it to the canvas
- 2Drag from a node's output handle to another node's input handle to create a connection
- 3Click a component to open its properties panel on the right
- 4Use the version drawer (top bar clock icon) to browse or restore previous versions
- 5Press Cmd/Ctrl+Z to undo, Cmd/Ctrl+Shift+Z to redo
Constraint-First AI Assistant
The AI panel is not a generic chatbot bolted onto a diagram tool. Every message the AI receives includes your full canvas state, your active constraints, and the architectural context of your current diagram. It reasons about your specific system, not some hypothetical one.
Before the AI can help you, you define your constraints: your target cloud provider (AWS, GCP, Azure, or multi-cloud), your monthly budget range, your expected traffic volume (req/s or monthly active users), your compliance requirements (SOC 2, HIPAA, GDPR), and your team size. These constraints are injected into every AI request — the AI will never suggest an architecture that violates them. No $2k/mo Kafka recommendations when you're on a $500 budget.
When you ask the AI a question, it has access to your full canvas: every node, every edge, every component property, and the current health score breakdown. You can ask "why is my health score 74?" and it will tell you which specific components are causing issues and what to fix. You can ask "add async processing between orders and fulfillment" and it will suggest the right queue technology based on your constraints.
When the AI suggests a structural change — adding a component, creating a connection, removing a problematic element — it comes with an "Apply to canvas" button. Click it and the canvas updates in real time. No copy-pasting, no manual dragging. The change is recorded as a version snapshot so you can always revert.
BackArch AI runs on Anthropic's Claude Sonnet — one of the most capable reasoning models available. Architecture decisions involve multi-step causal chains, tradeoff analysis, and constraint satisfaction across many dimensions simultaneously. Sonnet handles all of it without losing context on your specific system.
The AI doesn't wait to be asked. When you add a component that creates a known antipattern — a queue with no dead-letter queue, a database with no replica, a service with no circuit breaker — it flags it in the chat pane immediately. You can dismiss the suggestion or apply the fix. It's like having a principal engineer watching over your shoulder, but without the passive aggression.
The AI retains the full conversation history for the duration of your session. Ask a follow-up question five messages later and it still knows what you were discussing. Reference an earlier suggestion, walk back a decision, or ask it to compare two approaches it proposed in the same session — the context is always there.
- 1Open the AI panel using the chat icon in the right toolbar or pressing "A"
- 2Set your constraints first — click the constraint tags at the top of the panel to edit them
- 3Ask the AI anything about your architecture in natural language
- 4Click "Apply to canvas" on any suggestion to immediately update your diagram
- 5Use "Explain more" to get a deeper technical breakdown of any recommendation
- 6Type /reset to start a fresh AI session while keeping your canvas intact
How BackArch works,
step by step.
Start from a blank canvas, pick one of the built-in architecture templates (microservices, event-driven, serverless, monolith, CQRS), or describe your system to the AI and let it scaffold the initial design. Diagrams are organized in projects — group related services, share projects with teammates, and keep everything in one place.
Open the constraint editor and define the boundaries your architecture must operate within: cloud provider, monthly budget, expected peak traffic, team engineering capacity, and compliance requirements. These constraints are the north star for every AI recommendation and health score penalty. A team of 3 engineers shouldn't be running a Kubernetes cluster — BackArch knows that.
Drag components from the palette onto the canvas. Connect them by drawing edges between handles. Configure each component's instance details in the properties panel. The live pricing sidebar updates in real time as you add, remove, or reconfigure components. The health score updates with every change and tells you exactly what's wrong.
Ask the AI anything. "What's the most cost-efficient queue for this workload on GCP?" "Add a caching layer before the database." "Why is my resilience score low?" The AI has full context of your canvas and constraints and will respond with specific, actionable suggestions — not generic best-practice platitudes. Apply changes to your canvas in one click.
Check your architecture health score — aim for 85+. Review each flagged issue in the health panel and resolve them one by one. Browse the pattern library to apply battle-tested patterns your design might be missing. Compare your stack's cost across AWS, GCP, and Azure and switch clouds if the numbers make sense. Export your final diagram as an architecture decision record.
Share a read-only or editable link to your diagram with stakeholders, teammates, or reviewers. The Version History drawer gives you a full audit trail of every structural change — who made it, when, and what the before/after looked like. Architecture is a living document; BackArch treats it like one.
Know your bill before
you write a line of code.
Infrastructure cost is one of the most consequential architectural decisions, and also one of the least-informed ones. BackArch turns cloud pricing from a spreadsheet exercise into a first-class design constraint.
1,000+ pricing records across 3 clouds
Every component in the palette maps to its real billing unit on AWS, GCP, and Azure. EC2 instances, RDS database classes, ElastiCache node types, Lambda invocation pricing, SQS message rates, S3 storage tiers — all of it is sourced from the providers' pricing APIs and refreshed weekly. When AWS changes their spot pricing, your diagram reflects it.
Per-component pricing in the properties panel
Select any component on the canvas and its properties panel shows you the exact monthly cost for the currently selected configuration. Change the instance type from t3.large to t3.xlarge and the price updates immediately. Switch from on-demand to reserved pricing and see the annual savings. Every configuration choice has a dollar sign next to it.
Side-by-side cloud comparison
The pricing sidebar aggregates every component's cost into a total monthly bill and breaks it down by cloud provider. For each diagram, BackArch automatically maps your component choices to their nearest equivalent on competing clouds and calculates what your stack would cost there. You see the delta in dollars and the projected annual savings or cost before you've provisioned a single resource.
AI-driven cost optimization
The AI assistant is aware of your component pricing at all times. When it detects that a cheaper alternative exists — equivalent performance, lower bill — it flags it proactively. "Switching from ElastiCache r6g.large to r6g.medium saves $63/mo with no observable latency impact at your traffic level." Every suggestion respects your constraint budget, so the AI never recommends a cost-optimization that pushes you over on another dimension.
AI and LLM model pricing
If your architecture includes AI inference — a RAG pipeline, an embedding service, a Claude-powered agent — BackArch tracks the token cost alongside your infrastructure cost. Compare Claude Sonnet, Haiku, GPT-4o, and Gemini Flash side by side. Your total monthly bill includes compute, storage, and inference in a single number.
Budget constraint enforcement
Set a hard budget ceiling in your constraint profile and the health score enforces it automatically. Any component or combination that pushes your total over the limit gets flagged as a budget violation — not just a suggestion, a scored penalty. The AI will proactively recommend cheaper equivalents before you finalize the design.
- 1Add any component to the canvas — its estimated cost appears immediately in the sidebar
- 2Click a component and configure its instance type in the properties panel to refine the estimate
- 3Open the full pricing panel to see the side-by-side AWS / GCP / Azure breakdown
- 4Ask the AI "what's the cheapest way to run this stack on GCP?" for a full optimization analysis
- 5Set a budget constraint and the health score will flag any component that exceeds your limit
Your architecture gets a grade.
And it should.
The health score is a 0–100 composite metric that updates in real time as you design. It's not a vanity number — every point maps to a specific, fixable issue in your diagram.
Single Points of Failure are silent killers. BackArch maps every path through your architecture and identifies components where failure brings down the whole system. A database with no read replica, a message broker with no standby, a critical service running as a single instance — all flagged with remediation suggestions.
Service-to-service calls without circuit breakers are a cascade failure waiting to happen. BackArch traces every synchronous call in your graph and flags unprotected connections. When a service degrades under load, circuit breakers prevent the failure from propagating upstream. The health check maps every missing one.
Message queues without DLQs silently drop failed messages. At 10k req/s, 0.1% failure rate means 10 lost messages per second — 864,000 per day. BackArch detects every queue in your architecture and flags those without a DLQ, showing you the estimated message loss rate based on your traffic constraints.
You can't fix what you can't see. BackArch checks whether your architecture includes appropriate observability components — a metrics layer (Prometheus, CloudWatch, Datadog), a distributed tracing setup (Jaeger, X-Ray, Tempo), and a log aggregation path. Services with no observability attached get flagged as operational blind spots.
Public-facing endpoints without an authentication layer are a critical vulnerability. BackArch traces every path from an external client to an internal service and verifies that an auth component (API Gateway, OAuth service, JWT middleware) sits on each path. Internal service-to-service calls are checked for mTLS or equivalent when your compliance constraints require it.
If you've set a budget constraint, every component's cost is measured against it. The health check flags individual components that exceed a reasonable per-service allocation and surfaces the total projected monthly spend vs. your budget ceiling. The AI will suggest cost-equivalent alternatives when a component is over budget.
- 1The health score ring is always visible in the top bar — click it to open the full health panel
- 2Each flagged issue shows the affected component(s) and a direct link to jump to it on the canvas
- 3Click "Fix with AI" on any issue to get an instant suggestion for resolving it
- 4Target a score of 85+ before considering your architecture ready for production planning
- 5The score updates live — fix an issue and watch the number climb in real time
40+ battle-tested patterns.
One click to apply any of them.
Design patterns encode decades of hard-won engineering knowledge. BackArch gives you every major backend pattern, categorized by concern, with difficulty ratings, tradeoff analysis, and direct integration into your canvas.
Halts calls to degraded services automatically to prevent cascading failures. Configure failure thresholds, timeout windows, and half-open retry behavior.
Retries failed requests with increasing delay intervals and jitter to avoid thundering herds. Essential for any service making network calls to external APIs or databases.
Isolates failures by separating resource pools per consumer. Prevents one slow upstream from consuming all thread pool capacity and starving other consumers.
Forces every external call to fail fast rather than hang indefinitely. Sets upstream SLOs that the rest of your system can depend on.
Separates read and write models for independent, elastic scaling. Write path can optimize for consistency; read path can optimize for query flexibility and throughput.
Horizontally partitions data across multiple database instances. BackArch shows you the shard key selection and the routing logic between application tier and shards.
Application manages the cache explicitly — read from cache, miss to DB, populate cache. Clean separation of concerns with no magic middleware.
Offloads read traffic to one or more replicas, leaving the primary for writes. The canvas will visualize the replication lag tradeoff.
Coordinates distributed transactions across microservices using compensating actions instead of 2PC locks. Choreography vs. orchestration tradeoff explained inline.
Persists state as an immutable append-only event log. Full audit trail, time-travel debugging, and event replay for free. BackArch visualizes the event stream topology.
Ensures atomic write + publish by writing to a local outbox table in the same transaction. A relay process polls the outbox and publishes to the message broker.
Achieves idempotent message processing by recording processed message IDs. Duplicate deliveries are safely ignored without re-executing business logic.
Single entry point for all client-to-service communication. Handles auth, rate limiting, SSL termination, request routing, and protocol translation in one place.
Injects a sidecar proxy next to every service instance to handle mTLS, observability, traffic management, and retries at the infrastructure level rather than the application level.
Creates dedicated API surfaces per client type — one for mobile, one for web, one for third parties. Each BFF aggregates and transforms upstream service responses for its specific consumer.
- 1Open the Patterns page from the sidebar or navigate to /patterns in the app
- 2Filter by category (Resilience, Scalability, Data, Networking, State) or search by name
- 3Click "Preview" to see an interactive canvas demo of the pattern before applying it
- 4Click "Use →" to add the pattern's components and connections directly to your active diagram
- 5Ask the AI "what patterns am I missing?" for a context-aware recommendation based on your current design
Your whole team.
One canvas. Live.
Architecture is a team sport. The canvas was designed from day one for multiplayer — every data structure, every sync mechanism, every UI element was built with collaboration in mind. Here's what's coming.
See your teammates' cursors, names, and selections in real time. Know who's working on which part of the diagram without asking in Slack.
No merge conflicts. No lock contention. BackArch uses CRDTs (Conflict-free Replicated Data Types) to merge concurrent edits mathematically — the same technology powering Figma's multiplayer.
Leave comments anchored to specific nodes or edges. Resolve threads as decisions get made. The full conversation history lives alongside the diagram.
Auto-generate ADRs from your design session. Every major structural decision — what was considered, what was rejected, why the final choice was made — captured as a living document.
Share diagrams as view-only, comment-only, or fully editable. Org-level permissions let admins define who can create, share, and export architecture diagrams.
Get notified when a teammate makes a structural change to a diagram you're watching. Never be surprised by an architecture decision made while you were offline.
Architecture as institutional memory.
Today, BackArch is a design and validation tool. Tomorrow, it's the single source of truth for every architectural decision your organization has ever made. Every diagram, every rejected alternative, every ADR, every cost tradeoff — preserved, searchable, and connected.
When a new engineer joins your team, they don't spend three months reverse-engineering why your system looks the way it does. They open BackArch, read the diagram history, and understand the full arc of architectural decision-making that shaped the system they're now responsible for.
When your CTO asks "why are we running on AWS instead of GCP," the answer isn't in someone's memory or buried in a Confluence doc from 2019. It's in BackArch — with the cost comparison, the compliance constraints, and the names of the engineers who made the call.
- Real-time collaboration (Y.js)
- ADR generator
- Team workspaces
- Terraform / Pulumi export
- GitHub integration
- Architecture diff view
- Drift detection (live infra vs. diagram)
- AI cost forecasting
- SOC 2 report generation
Your architecture deserves
the right tools.
Free forever for solo developers. No credit card. No setup friction. Just open the canvas and start designing the system you've been thinking about.