Introduction

DevXStream is a deterministic backend infrastructure generator. It converts structured inputs (SQL schemas, configurations, AI suggestions) into production-ready backend systems with enforced architectural boundaries.

Not a scaffolding tool

DevXStream does not generate arbitrary scaffolding. It enforces structure through deterministic generation and clean architecture principles.

Core Principles

Deterministic generation

Identical inputs always produce identical outputs.

Enforced Clean Architecture

Strict separation of concerns built-in.

Controlled AI assistance

AI suggestions are validated against architectural rules.

Regeneration safety

Update structure without losing custom code.

System Architecture Overview

DevXStream enforces a strict layered model where dependencies flow inward only. This ensures that your business logic (Domain) remains independent of external frameworks or databases.

Architecture View

Infrastructure

API

Application

Domain

Dependencies flow inward: API → Application → Domain ← Infrastructure

Domain Layer Core business logic and entities. No external dependencies.

Application Use cases, CQRS handlers, and service interfaces. Orchestrates logic.

Infrastructure Implementation of interfaces (EF Core, Email, File System).

API Layer Controllers, middleware, and entry points.

Getting Started

1

Create a Project

Sign in to the console and initialize a new project workspace.

Supported Architecture Types

Clean Architecture Vertical Slice Modular Monolith Microservices

2

Import Schema

Upload a SQL file or connect directly to an existing database to reverse-engineer your domain.

SQL Server

PostgreSQL

MySQL

3

Configure Generation

Select the infrastructure blocks you need. These are enforced during the generation phase.

Authentication (JWT/OAuth)
Multi-tenancy
Structured Logging
Validation Pipeline
Distributed Caching

Generation Process

The engine generates a comprehensive solution structure including Domain Entities, CQRS Handlers, Repository Interfaces, and API Controllers.

Example Folder Structure

/src

/Domain

/Entities

/Events

/ValueObjects

/Application

/Common

/Features

/Orders

CreateOrderCommand.cs

OrderCreatedEvent.cs

/Infrastructure

/Persistence

/Services

/API

/Controllers

/Middleware

Output Artifacts

Domain Entities

Rich domain models with behavior.
CQRS Handlers

Separated command and query logic.
Infrastructure

EF Core configurations and migrations.

AI & Core Engine

AI Layer & Regeneration

The AI Layer uses LLMs to suggest domain models, while the Regeneration Engine ensures custom code in /Custom folders is never overwritten.

Multi-Tenancy

Supports Schema-per-tenant or Column-per-tenant isolation strategies out of the box.

Platform & Security

Security Defaults

Automatic implementation of OWASP Top 10 protections, including rate limiting and SQL injection prevention.

Credits & Licensing

Usage is based on generated LOC and active architectural blocks.

Template Engine

Custom Scriban templates for Enterprise users.

Enterprise Support

24/7 technical support and dedicated architecture review sessions.

CLI Usage

The CLI respects the same deterministic rules as the Web UI and is perfect for CI/CD pipelines.

Installation

devxstream install

Generate Project

devxstream generate --project MyProject --architecture clean --db postgres

Regenerate (Safe Mode)

devxstream regenerate --project MyProject --safe

FAQ

Is DevXStream a no-code platform?

No. It generates structured, high-quality backend code that you own and maintain. It accelerates the initial setup and boilerplate phases.

Can I modify generated code?

Yes. We use partial classes and protected regions to ensure you can extend the logic. Custom code in specific directories is preserved during regeneration.

Can I use my own templates?

Enterprise plans allow for custom template configuration using our Scriban-compatible engine.