01 / 08 Case study

RustDX

A modular pre-1.0 Rust framework and project structure: 87 packages, explicit authority boundaries, and a QA system that treats evidence as part of the architecture.

87

Cargo packages in the audited workspace

13

Structural templates with no imposed UI

0.1.0

Current pre-1.0 boundary

02 / 08 The system problem

Repeatable infrastructure should not be rebuilt for every product

RustDX separates reusable contracts, policies, adapters, templates, and quality tooling from the product interface that consumes them. It is not a finished website or a universal product. It is a verifiable foundation that lets each downstream application keep its own identity and authority.

Modularity

From kernel to product without reversing dependency direction

Shared primitives sit below horizontal capabilities, vertical modules, and composition templates. Products consume those layers; the framework does not acquire their domain authority.

Authority

Policy stays in front of providers

Storage, mail, cache, and payment adapters cannot bypass domain authorization, auditing, or transaction policy simply because they touch external infrastructure.

Honest maturity

A contract is not presented as an operated production service

The repository distinguishes implemented paths, tested contracts, prerequisite-bound tests, and responsibilities that remain with each downstream application.

03 / 08 Engineering foundation

One Rust workspace for application primitives, product modules, native contracts, and delivery tooling

The framework spans kernel primitives, auth, APIs, data, CMS, ecommerce, marketplace, digital products, six vertical contracts, native policy, Dioxus/SSG integration, and creation, security, and quality tooling.

  • Rust
  • Dioxus
  • SQLite
  • PostgreSQL
  • Static delivery
  • Native contracts
  • Security gates
  • Supply-chain policy

04 / 08 Architecture flow

From a stable kernel to a product that remains application-owned

Dependency direction is deliberate: each layer consumes the one below without allowing infrastructure to dictate product behavior.

  1. K

    Kernel

    Errors, configuration, validation, security, and resilience.

  2. P

    Primitives

    Auth, APIs, forms, data, cache, storage, and mail.

  3. H

    Horizontal modules

    CMS, commerce, marketplace, digital delivery, reviews, and moderation.

  4. V

    Vertical contracts

    Games, books, audiobooks, plugins, software, and courses.

  5. A

    Application

    The product owns UI, providers, secrets, operations, and deployment.

05 / 08 Decisions

The decisions that shape the system

  • Implemented

    Explicit transaction boundaries

    Multi-write registration and digital entitlement paths use unit-of-work contracts instead of allowing partially persisted authority.

  • Implemented

    Security blocks release

    Evidence includes denial-oriented tests, bounded inputs, redacted values, dependency policy, fuzz and mutation tooling, and generated CSP checks.

  • Contract

    Native targets are not presented as shipped apps

    Thirteen native packages define lifecycle, capability, packaging, and release evidence; signing, stores, and real-device operation stay external.

  • Product-owned

    No framework-imposed interface

    Templates are structural and visually neutral. The downstream product selects design, content, providers, and operating environment.

06 / 08 Verifiable evidence

What exists in the workspace today

  • 87 Cargo packages across framework crates, templates, examples, extensions, and infrastructure scaffolding
  • 13 structural templates and 20 examples that demonstrate composition without presenting themselves as finished products
  • Deterministic in-memory adapters plus SQLite and PostgreSQL implementations for implemented persistence surfaces
  • Static build, reproducibility, deployment-contract, delivery, and rollback tooling kept distinct from claims of operated production deployment
  • Documented residuals: live PostgreSQL, external providers, signed native packages, and v1 compatibility remain separate gates

08 / 08 The next move

Need a foundation that will not constrain the product after its first release?

I can help establish the architecture, boundaries, and quality system before complexity becomes a tax on every future change.

Discuss the architecture->Explore architecture services