Why we built Dawnshard
This is the first post about Dawnshard, the engine underneath everything SaasyBits builds. It is not a product and it will never be sold. Unless you have cash. Then let's talk ;) It exists so that the things we do sell can be built properly, and this post explains what that means and why we went that way.
What we built
SaasyBits is the studio. Plan.Make.Trace is the product. Dawnshard is the thing in between: our internal collection of application primitives, the core that products get built on top of.
It handles the parts every serious application needs, and rebuilding that shit over and over sucks. Entity definitions, access control, validation, lifecycle, routing, realtime updates. A product built on Dawnshard inherits all of that on day one.
That is not just a time saving. It means our time goes into talking to users, shipping changes off the back of what they tell us, and working out whether we have actually built something people want. Not into rebuilding the same infrastructure for the third time.
Dawnshard predates Plan.Make.Trace. It was started for a different application, and when Plan.Make.Trace came along it turned out to carry across almost untouched. That portability was the point, and it was the first real evidence the approach worked.
The problem it solves
Conventional web applications have a shape, and once you have built a few you can see it coming. Every new feature means the same scaffolding: a model, a controller, a set of endpoints, access checks written out again, validation written out again, lifecycle rules written out again. None of it is hard. All of it is repetition, and repetition is where mistakes hide.
Then there is the split. The backend defines what a batch is. The frontend defines what a batch is, again, separately. Two definitions of the same concept, maintained by hand, drifting apart one small change at a time. Eventually someone adds an exception on one side, then a hack on the other to reconcile them, and now the truth about a batch lives in two places that disagree.
The deeper problem is what happens over time. Entity boundaries blur, logic gets duplicated across layers, and each new feature is slightly harder to add than the last. Eventually the codebase resists you. Adding something new means touching things that already work, and touching things that already work is how you break them.
There is a strand of SaaS dogma that treats all of this as the price of shipping fast. Don't reinvent the wheel, use the standard CRUD architecture, get something out the door. There is value in that, right up until you discover you shipped the wrong thing. Shipping the wrong thing fast has very little value if the architecture then makes changing it slow.
What a games background changes
I came to this from games and simulation, and that background makes one thing obvious that web development somehow does not: these applications are entity state management systems. That is all they are.
Games manipulate enormous quantities of entity state continuously, often sixty times a second, and they do it by being data driven. You declare what an entity is as data, and reusable systems operate on it. You do not write bespoke machinery for every entity type, because at that scale you plainly cannot.
Web applications update comparatively tiny amounts of state, and treat it as inherently slow and difficult. Waiting seconds for a refresh. Fetching the same state repeatedly. Cross-entity changes that require touching half the codebase. Coming from the other discipline, that is a strange thing to accept as normal.
This is also where my interpretation of MVC matters. The model is the domain. It should still be the same domain whether you are interacting with it through a browser, a terminal, a mobile app or the freaking holodeck. The view changes how we see that data. It should not change what that data is. And how the data is controlled should not depend on how somebody happens to be looking at it.
A lot of SaaS applications lose that separation as they grow. Here is a card for an entity on one page. Here is the same entity represented by another card somewhere else. Here is a slightly different list implementation on a third page. Each one accumulates its own assumptions, formatting, behaviour and styling until the domain is no longer really represented by the model. Pieces of it are scattered throughout the views.
That makes changes which should be simple surprisingly expensive. Show the same data in ten places and you can end up maintaining ten slightly different implementations of it. Bake styling into those components and suddenly changing a theme means hunting through the application fixing individual views.
Dawnshard is deliberately built to keep those boundaries clean. The model defines the domain and its state. Views represent it. Controllers and services coordinate how that state is acted on. A different view should not require a different definition of the thing being viewed.
So Dawnshard is built the way an engine is built. You declare what an entity is, once, and the systems around it operate on that definition. That shape runs through all of it: the model system, services, lifecycle, access control, routing, the realtime engine, the state graph.
What makes this different
The practical difference is that new feature domains can be added in isolation, without modifying the core and without destabilising anything already running.
That is the property most architectures lose first. Dawnshard is built to scale horizontally across domains, with each new area of functionality standing on its own, and then deeply vertically within each one as it grows. An entire new domain can arrive without the existing ones noticing.
Underneath that is the thing the whole design rests on: clean encapsulation and abstraction. The core defines contracts, and the concrete implementations behind those contracts stay replaceable. Capabilities arrive as plugins and extensions, which means a product can add what it needs without contaminating the core or pushing its own assumptions down into it.
That also keeps us out of the usual lock-in trap. The database, the realtime transport, the mail provider and the other concrete technologies are implementations sitting behind contracts. They are not load-bearing decisions baked throughout the application. Swapping one is a job. It is not a rewrite.
The difficult, generic capabilities live in the core and stay there. Products customise and extend them, but never have to reimplement them, and never inherit another application's assumptions about access control or domain structure. Dawnshard and Plan.Make.Trace already demonstrate that separation in practice.
What this unlocks
For us, it means a good market opportunity does not start from scratch. The core is already there, already tested, and the work goes into the product rather than into rebuilding foundations.
More importantly, it means we can change direction without throwing those foundations away. User feedback can change a workflow, a feature or even an entire product direction without requiring us to rebuild the machinery underneath it. That matters when the goal is not just to ship quickly, but to find the right thing to ship.
For anyone waiting on Plan.Make.Trace, it means features arrive faster and more reliably than they otherwise would, because most of what sits underneath them was solved before that product existed.
What's next
The next post covers models and the base service, which is where the philosophy stops being abstract. Define an entity once, and the engine supplies the common behaviour around it: storage, validation, field level access, permissions. It is the clearest example of the whole idea, and everything after it builds on that foundation.
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