Solarch

Product Introduction

1. Definition: Solarch is a backend architecture design and code generation platform categorized as a Diagram-to-Code and Architecture-as-Code tool. It employs a live node/edge canvas powered by a strict, default-deny Rules Engine and a hybrid deterministic-AI code engine.
2. Core Value Proposition: Solarch exists to eliminate architectural drift by inverting the standard development process: it generates the validated architecture first, then produces deterministic code skeletons from that verified graph. This ensures the codebase is structurally sound from inception, building the repetitive 80% of boilerplate (DTOs, Services, Repositories) so developers can focus on core business logic.

Main Features

1. Canvas & Visual Architecture: Draw backend systems as a live, interactive node/edge graph on a unified canvas. It features Fractal Graph semantics for zooming from macro modules (like "Orders" or "Payments") down to micro-graphs of individual components. Nodes represent elements across 8 semantic families (Data, Business, Access, Infra, Client, Security, Config, Structure), connected by 16 typed relationships (e.g., "calls", "queries", "creates").
2. Rules Engine (Default-Deny Validation): A core differentiator that enforces canonical architecture patterns in real-time. It operates on a default-deny principle, automatically rejecting illegal connections—such as a Controller directly accessing a Table—the moment they are drawn. This engine enforces 7 anti-patterns and 3 conditional checks, providing immediate feedback and preventing invalid structures from entering the pipeline.
3. Hybrid Code Engine (Deterministic + Surgical AI): A two-stage process for code generation. Stage 1 is a deterministic compiler that transforms the validated graph into a type-safe code skeleton (DTOs, entities, constructor injection) using zero AI tokens. Stage 2 utilizes a surgical AI to fill in only the empty function bodies of that skeleton with algorithmic logic (~300 tokens/function), ensuring architectural consistency.
4. Vector Export & Autonomous QA: The platform can export the architecture as an AI-readable vector memory, turning your system design into a knowledge base for other AI tools. It also includes Autonomous QA capabilities, featuring smart seeding for automated testing and time-travel snapshots for tracking graph evolution.
5. Developer Ecosystem Integration: Generates output as code, Mermaid diagrams, or API contracts. It is specifically designed for compatibility with modern AI coding assistants like Cursor & Claude, providing a grounded architectural context for code generation within those IDEs.

Problems Solved

1. Pain Point: Eliminates architectural drift, where diagrams become outdated as code evolves. It also solves the "blank canvas" problem for backend design and removes the tedious manual creation of boilerplate code and type definitions.
2. Target Audience: Backend Developers, Software Architects, Full-Stack Engineers, Tech Leads, and DevOps Engineers working with complex, multi-service systems (especially microservices) using languages like TypeScript/JavaScript and frameworks like NestJS.
3. Use Cases: Designing and scaffolding microservices architectures (e.g., cart & checkout flows); Enforcing coding standards and architectural patterns across teams; Rapid prototyping of backend systems with guaranteed structural validity; Generating type-safe API contracts and database schemas from a visual model; Creating comprehensive system documentation that stays in sync with code.

Unique Advantages

1. Differentiation: Unlike AI code generators (e.g., GitHub Copilot, Cursor) that propose code and hope the architecture holds, Solarch proposes architecture first. It is the inverse of the "generate code and refactor" approach. The Rules Engine acts as a continuous, pre-commit CI check on design, catching violations in seconds rather than in later code reviews.
2. Key Innovation: The architecture-first, rules-verified pipeline is the core innovation. Combining a default-deny validator with a deterministic code compiler ensures that the system's structural integrity is mathematically provable before a single line of application logic is written by the AI.

Frequently Asked Questions (FAQ)

1. What is Solarch, and how does it work? Solarch is a backend architecture platform that lets you draw systems as validated node/edge graphs. A strict Rules Engine checks every connection in real-time. From the verified diagram, it uses a hybrid engine to generate a type-safe code skeleton deterministically, then employs AI to fill in the business logic functions.
2. How is Solarch different from AI coding tools like Copilot or Cursor? While tools like Copilot generate code directly, Solarch focuses on the architectural foundation first. It guarantees that the underlying design is valid and pattern-compliant before code generation, whereas other tools risk propagating architectural anti-patterns. It then exports code that is Cursor & Claude Ready.
3. What does the "default-deny" Rules Engine actually prevent? The Rules Engine prevents architectural anti-patterns by default. For example, it will reject the moment you try to draw a direct connection between a Controller node and a Database Table node, enforcing that it must route through a Service or Repository. This prevents invalid relationships from ever becoming part of the generated codebase.
4. What kind of code does Solarch generate, and for which technologies? Solarch generates deterministic boilerplate (DTOs, entities, constructors) and AI-scaffolded function bodies, primarily targeting backend stacks like TypeScript/Node.js with NestJS. The output includes the API contracts, data models, and service layer structures that form a compilable, type-safe project foundation.
5. Is Solarch only for new projects, or can it integrate with existing codebases? Solarch is primarily designed for designing and scaffolding new backend systems or modules from a validated blueprint. Its core value is establishing a correct architectural foundation upfront, making it ideal for greenfield development or adding well-defined new services to an existing system.