Basalt Is Becoming More Than an Architecture Generator
When we started building Basalt, the idea was relatively simple:
make system architecture easier to create.
A few iterations later, that idea has grown into something much bigger.
Basalt is becoming a place where architecture can be generated, explored, validated, refined, and eventually governed.
And that's the direction we're taking.
From a blank canvas to an intelligent workspace
Architecture traditionally starts with a blank screen.
Boxes.
Arrows.
A lot of thinking.
A lot of documentation.
A lot of time.
We're trying to change that workflow.
With Basalt, you can start from a requirement, an idea, an existing system, or one of our architecture templates and move directly into a structured environment for designing the system.
The canvas isn't supposed to be the end result.
It's supposed to be the workspace where the system evolves.
We've been building the layers around the architecture
The architecture itself is only one piece.
We've been adding the surrounding layers that make it useful in actual engineering workflows:
Architecture generation
Create structured architectures from requirements and engineering context.
Templates
Start from predefined architectural patterns instead of rebuilding common systems from scratch.
SDE Lens
Look at architecture from the perspective of the developer who has to build, modify, debug, and maintain the system.
Architecture Validator
Evaluate diagrams against structural and architectural rules rather than simply generating them.
Custom rulesets
Allow organizations and teams to define their own architectural constraints.
GRC direction
Move architectural governance closer to the design process instead of treating compliance as something checked at the very end.
And we're continuing to build on top of these layers.
The validator changed the way we think about Basalt
One of the biggest shifts has been realizing that generating an architecture isn't enough.
An AI can generate a diagram.
But then comes the more important question:
Does the architecture actually satisfy the requirements?
That's why validation has become a core part of Basalt.
The workflow starts looking more like:
Design
↓
Generate
↓
Validate
↓
Identify Issues
↓
Refine
↓
Validate Again
That feedback loop is much more interesting to us than simply producing another pretty diagram.
Architecture should have rules
Different systems have different constraints.
A financial platform isn't designed exactly like an industrial control system.
A cloud-native SaaS product isn't designed exactly like an enterprise ERP environment.
And an Industry 4.0 system introduces another completely different set of considerations.
So we're moving toward architecture that can be evaluated against explicit rules and standards, rather than relying entirely on manual review.
That opens the door to something much larger:
Automated architectural governance.
And then there's Industry 4.0
This is one of the areas we're particularly excited about.
Modern industrial systems increasingly sit across multiple layers:
Physical Systems
↓
Sensors / PLCs
↓
Edge
↓
Industrial Network
↓
Cloud / Data
↓
Analytics / AI
↓
Enterprise Systems
Designing these systems isn't simply about putting components on a canvas.
There are interfaces, dependencies, security boundaries, communication patterns, standards, and operational constraints to consider.
That's exactly the kind of environment where structured architecture and automated validation become increasingly valuable.
Basalt is becoming an architecture operating layer
That's probably the simplest way to describe where we're heading.
Not just:
"Generate me a diagram."
But:
"Help me design, understand, validate and evolve this system."
The architecture becomes a living artifact.
Something engineers can work with.
Something architects can review.
Something organizations can apply rules to.
Something that can evolve as the underlying system evolves.
We're still early
Basalt has gone through multiple iterations already.
Each one has changed something:
The UI.
The architecture engine.
The validation layer.
The developer experience.
The templates.
The governance direction.
And the way we think about what an architecture platform should actually be.
We're still experimenting.
We're still breaking things.
We're still rebuilding parts that looked perfectly fine a week earlier. 😅
But the direction is becoming clearer.
Basalt isn't just about drawing architecture anymore.
It's about making architecture computable.
And that's the part we're excited about.
More soon. 🌋
Top comments (0)