Our favourite technology

We work with a top technology stack that we cherish and maintain. We keep our finger on the pulse of time, but don't run after every trend either.

We develop backends with Java and host with Docker.

For frontends, we rely on Angular, Vue.js or Nuxt, depending on the project.

For databases, we are flexible, but prefer to use No-SQL technologies like MongoDB and Elasticsearch.

But even with technology, one thing is important to us: it's an (extremely cool!) tool to make people's lives better, but not an end in itself.

We automate routine topics with the help of code generators. This means that our projects get off the ground faster and contain fewer errors.

Above all, we gain time that we can spend on the really interesting aspects of your project - after all, we want to solve the tough challenges together!

We generate many aspects of web projects automatically, including objects and database queries, many standard processes, interfaces and back-office UIs.

But we don't stop after one generation. Our generators allow software to evolve iteratively and also to be modified manually. In this way, we continue to develop by hand until everything works as it should.

And because there is not one big generator, but many small ones for different topics, we put them together individually for each project. Everything is assembled the way it fits best for the project.

Clean Architecture

Our projects are as diverse as our customers. That's why it's especially important for us that everything is in its place and that we maintain an overview. We therefore work with a uniform but extremely flexible software architecture: It's called "Clean Architecture" - and we love it!

Business structures and processes can be implemented largely without technical dependencies. This makes our solutions scalable and the system components interchangeable. In practice, this means that our solutions grow with you, even if the rest of the world changes.

By the way, this works equally well for lean microservices and for strong monoliths - here we decide together what suits you best.

Domain Driven Design

Because the core of our solutions revolves around the "domain", i.e. the technical world of the project, our software also contains exactly those objects and processes that are important in your business. We want to understand them and mold them as accurately as possible into software.

This sounds like a matter of principle - but it is not. That's why this approach even has its own name: Domain Driven Design. It allows us to easily implement most business requirements, even if they become more complicated or change over time - and hey, they always change at some point.

Did we mention that this also makes the code understandable and easily maintainable? That helps us all in the end.

Because we can autogenerate so much code and use a uniform architecture, we also have plenty of features ready to go that other teams spend a lot of time on, yet we can easily enable when needed. For example: