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.
Typical situations where JoinedWorkz helps
- Architecture guidelines live in Confluence or slide decks, but every project interprets them differently and consistency across teams is hard to enforce.
- Teams repeatedly build similar CRUD-style services and APIs with small variations, spending time on boilerplate instead of focusing on business logic.
- OpenAPI or other interface specifications drift away from the implementation and are difficult to keep in sync across services and repositories.
- New developers need a long time to understand how persistence, APIs and integration patterns fit together in a system that has been evolving for years.
JoinedWorkz addresses these situations by moving your rules and patterns into generators, so that compliant code becomes the default outcome instead of a guideline people need to remember.
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.
Consulting, project support & custom generators
JoinedWorkz is typically introduced as part of a project, not as a self-service tool installed in isolation. The real leverage comes from custom generators that encode your architecture guidelines and integration patterns.
JoinedWorkz is developed and supported by JoinedSystems. Project accompaniment can include for example:
- Clarifying goals and choosing a concrete pilot scope (for example one or two services)
- 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
- Adjusting generators based on feedback from real projects and evolving architecture guidelines
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.