Consistent architecture, by default
Persistence, API and controller layers follow the same patterns across teams and projects. Instead of relying on “please follow the guidelines”, the generator simply emits compliant code.
DSL-based modeling & generation for APIs and backend systems
Keep your architecture consistent.
Generate the boring parts.
JoinedWorkz lets you model persistence, APIs and controllers in a platform-lean DSL and generate consistent, standard-compliant code. Standardize persistence and APIs while keeping developers in full control.
What is JoinedWorkz?
JoinedWorkz is a modeling and generation toolchain that lets you describe your application’s structure in a domain-specific language and generate standard code for persistence, APIs and controllers. The model is kept close to the implementation: you use standard diff and merge tools, and the generated code can live in the same repositories as your hand-written business logic.
Studio
A standalone modeling studio for defining your DSL models, including transformations to a simple, generator-friendly internal model that does not add extra framework dependencies.
Standard generators
Generators that build on the transformed model, producing OpenAPI specifications, Spring Boot components and other commonly needed infrastructure code.
Maven build integration
A Maven plugin that integrates generation into your build lifecycle. Generators are versioned as Maven modules, so teams can evolve them just like any other dependency.
Why architects & managers care
Architecture guidelines in Confluence are only useful if they are applied. JoinedWorkz moves your design rules into generators that produce code according to these rules – without adding extra work per project once the generator exists.
API-first with real code behind it
Model your APIs first and generate OpenAPI specs and backing components from the same source. The model gives a clear overview for onboarding while the generated code is ready for implementation.
Better onboarding & transparency
New team members start from a model that reflects the current system, not a stale diagram from months ago. Because code is generated from the model, it is always aligned with what runs in production.
Cost-efficient standardization
Investing once in a generator makes architecture decisions reusable. Each new project reuses the same generator instead of re-discussing and re-implementing the basics.
Governance without micromanagement
Teams keep autonomy for business logic, while infrastructure, integration patterns and conventions stay within agreed boundaries enforced by the generator.
Why developers can live with it
Developers are rightfully skeptical when tools dictate how code must look. JoinedWorkz is explicit about what it generates – and what stays in your hands.
Plain code, no hidden runtime
Generated code is regular project code, not a black box runtime. It can be checked in, reviewed, refactored and extended like everything else in your repository.
No lock-in to the generator
If a team decides to stop using a generator, the existing code keeps working. There is no proprietary runtime that must stay around forever just to keep the system alive.
Textual DSL, Git-friendly
The DSL uses text files that play nicely with Git. Diff, merge and code reviews work with the same tools you already use for your code.
Business logic stays manual
JoinedWorkz generates the scaffolding: persistence, APIs, controllers and integration points. The actual business logic remains hand-written and under full control of the development team.
In short: JoinedWorkz standardizes the parts that are usually repetitive and architecture-heavy, not the domain-specific logic where teams need freedom.
How it works
1
Model
Use the JoinedWorkz modeling studio to model your domain, persistence, APIs and controllers in a DSL that is focused on your architecture, not tied to a specific platform.
2
Transform & generate
Transform the model into a technology-neutral representation and run generators that produce OpenAPI specs, Spring Boot code and other infrastructure components.
3
Build & evolve
Integrate generation into your Maven build. Treat generators as versioned Maven modules so they can evolve alongside your architecture without disrupting running projects.
Project support & custom generators
The real leverage comes from custom generators that encode your architecture guidelines and integration patterns. For most organizations, having support when defining and implementing these generators is highly recommended.
JoinedWorkz is developed and supported by JoinedSystems. Project accompaniment can include:
- Defining the modeling approach and scope for your first projects
- Designing and implementing custom generators tailored to your standards
- Integrating generation into existing build pipelines and repositories
- Coaching teams on how to work effectively with the model and generated code
Ready to explore JoinedWorkz for your organization?
Whether you want to standardize APIs and persistence across teams or simply reduce the friction around recurring boilerplate code – JoinedWorkz gives you a model-driven path that standardizes persistence and APIs while keeping developers in full control.