Every backend developer has experienced this moment.
You start a new project. You already know the architecture in your head. Maybe it is a simple REST service with a database. Maybe two services communicating with each other. But before you can work on real logic, you spend time doing the same setup again.
- Create the project.
- Add dependencies.
- Create entities.
- Create repositories.
- Create services.
- Create controllers.
- Wire everything together.
None of this is hard. But it is repetitive.
That is why I started building Archify.
Archify is a tool that turns an architecture idea into a ready to run Spring Boot project.
Instead of manually creating boilerplate, you define the architecture and Archify generates the code.
The Problem
Modern backend development is heavily architecture driven. When starting a project we already know the basic structure.
For example:
- A REST service
- A PostgreSQL database
- A few entities
- CRUD APIs Maybe multiple services communicating with each other But tools today only solve part of the problem.
Spring Initializr helps you create a basic project skeleton. It adds dependencies and basic configuration. But it does not generate actual application structure like entities, repositories, or controllers.
Other tools often require complex configuration or opinionated frameworks.
What developers often want is something simpler.
- Define architecture.
- Generate working code.
The Idea Behind Archify
Archify takes a different approach.
Instead of starting from a project template, you start from an architecture recipe.
For example:
- REST service with PostgreSQL.
- Or two services communicating via REST.
- Once the recipe is selected, you define the domain model. Example:
User
name: String
email: String
Archify then generates a complete Spring Boot service with:
- Entity
- Repository
- Service layer
- REST controller
- Database configuration
- Maven build setup
The generated project can be started immediately.
./mvnw spring-boot:run
Architecture as YAML
One feature I wanted to support early was a simple way to share architectures.
Instead of describing architecture in text, Archify lets you export it as YAML.
Example:
recipe: rest-postgres
serviceName: user-service
entities:
- name: User
fields:
- name: name
type: String
- name: email
type: String
This YAML becomes a shareable architecture blueprint.
You can send it to a teammate.
Store it in documentation.
Use it in examples.
Anyone can paste the YAML into Archify and generate the same project.
Visual Architecture Preview
Another goal was to make architecture visible.
When selecting a recipe, Archify shows a simple diagram representing the architecture. For example a service connected to a database or two services communicating with each other.
The preview updates as the configuration changes. This helps developers understand what they are generating before any code is created.
Current Scope
Archify is currently focused on common backend patterns such as:
- REST service with H2
- REST service with PostgreSQL
- Two services communicating through REST The goal is not to cover every possible architecture but to make common setups quick and easy.
Why I Built It
The idea came from repeated friction when starting new backend services.
Even experienced developers spend time creating the same scaffolding again and again. That time could be better spent building real features.
Archify tries to remove that friction.
- Describe the architecture.
- Generate the service.
- Start building.
What’s Next
The next steps for Archify include:
- More architecture recipes
- Sharing architecture blueprints
- Better visualization of service interactions The long term vision is to make architecture definition the starting point of backend development.
Try It
Archify is open source and available on GitHub.
If you build Spring Boot services regularly, I would love your feedback.
The project is still early, but the goal is simple.
Make it easier to turn architecture ideas into working backend code.
Top comments (0)