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 and even UI flows in a platform-lean DSL. From a single model, generators produce consistent code for multiple stacks – while your teams keep full control of the business logic.
What is JoinedWorkz?
JoinedWorkz is a modeling and generation toolchain that lets you describe your application’s structure in a domain-specific language. From this model, generators create standard code for persistence, APIs, controllers, UI flows and supporting infrastructure. The model is close to the implementation: it uses textual files, lives in Git, and integrates with your usual diff/merge workflow. Generated code can reside in the same repositories as your hand-written logic and evolves with your architecture.
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 and produce specifications and code for multiple platforms – including Java, Spring, Vert.x – with more to come.
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.
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.
- API or interface specifications drift away from the implementation and become hard 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.
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 machine-readable specifications and backing components from the same source.
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, integration points and (optionally) UI structure. The actual business logic remains hand-written and under full control of the 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 specifications and infrastructure code for the platforms you use (e.g. Java frameworks, UI stacks, or service interfaces).
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, persistence and UI flows across teams or simply reduce the friction around recurring boilerplate – JoinedWorkz gives you a model-driven path that standardizes the essentials while keeping developers in full control.
Not sure yet? - Download the PDF overview