← All posts

Building the Plan.Make.Trace domain

The Dawnshard series covered the foundation: models, services, identity, state, realtime, business rules, the persistence boundary, routing, and the extension mechanism. This post is where that stops being a description of infrastructure and starts being a description of a product.

What we built

Plan.Make.Trace is built entirely as a Dawnshard extension. The core lives in its own submodule. The product domains live in the application layer: recipes, batches, inventory, orders, business details, and the soap-specific data that sits across those areas.

Each domain follows the same shape described in the earlier posts and is added entirely within the application layer. Adding a new domain is a contained operation.

The domain groups cover the production workflow: ingredients and inventory, recipes and their soap-specific properties, production batches, and orders. There are supporting domains for business structure and system-level concerns like attachments and comments. The individual areas will get their own posts. This one is about what it looked like to build the first layer.

The problem it solves

Plan.Make.Trace is being built as a manufacturing system from the ground up, with traceability and end-to-end visibility as first-class concerns. It is not a formulation calculator that gradually accumulated inventory features, or an inventory system with recipes bolted onto the side. The domains are being designed together around the manufacturing process they need to support.

Dawnshard gives us the ability to go deep into individual manufacturing verticals without turning those vertical concerns into core platform concerns. We are starting with soap, where recipes, ingredients, purchasing, inventory, batches and finished products can be modelled in the depth the industry requires while still participating in one connected manufacturing system.

The goal is not simply to manage each part of production. It is to preserve the relationships between them so a product can ultimately be traced through the complete process, from what was purchased and received, through formulation and production, to what was actually made.

The challenge

Dawnshard had been built largely in isolation. The extension mechanism, the plugin contracts, the model registration system: all of it existed and had been tested. But it had not been exercised by a product at this scale.

Plan.Make.Trace was the test. A substantial product domain, implemented downstream, without touching the core. The question was whether that was actually possible or whether real product requirements would force changes back into Dawnshard.

The answer was that it worked. The product domains arrived without modifying the core. That is not a theoretical property of the architecture. The codebase now demonstrates it.

What makes this different

The recipe model is deliberately generic. It defines a recipe as a named, versioned thing with ingredients and a weight. The soap-specific behaviour sits in a separate 1:1 extension: the soap bar configuration with its production method, lye type, curing time, and superfat percentage.

That separation is intentional. Other recipe types can exist without pushing their concerns into the generic recipe domain. Same pattern as Dawnshard itself: add what you need, do not contaminate what should stay general.

Every domain gets RBAC, validation, field-level access, lifecycle, and realtime updates without wiring any of it up. A domain author defines the object and the behaviour specific to it. The engine handles the rest.

What this unlocks

For soap makers using Plan.Make.Trace, it means the software is actually shaped around how soap making works. The formulation tools, the batch workflow, the inventory system can be built and deepened without pulling on each other, because the separation is structural.

The next posts go into those areas individually.

Liked this post? Tap the heart to let us know.

Get early access

Be the first to hear about early access, roadmap updates, and exclusive early adopter pricing.

Join the early access list