WHAT FOR WE

STAND FOR


Less managing.

More creating.

We are a software company that develops and operates its own core insurance system—not an insurer that views IT as a cost center, but a product company that manages its own tech stack. Our stack includes Java 21, Quarkus, Cloud Native on Kubernetes, Angular, and lit-html in a micro-frontend architecture, as well as GitOps with Argo CD.

Insurance logic is one of the most challenging domains in software development. It is regulated, process-driven, and unique to each client. What we build must be able to fully capture this complexity— reliably, scalably, and without compromising code quality.

On our team, we work on software that runs in production every day and is simultaneously undergoing an active technological transition. Real users, real stack, real responsibility.

Our Four Engineering Divisions

  • We are working with Java 21 and Quarkus on a cloud-native architecture that is currently undergoing active development, and we are actively shaping this transition.

  • We model and implement business processes in BPMN 2.0 (CIB Seven) because, in our system, no state change occurs without a process behind it.

  • We make architectural decisions collaboratively as a team. Which approach is more stable, scalable, and maintainable? Everyone is part of this discussion.

  • We don’t deliver on a whim. Peer reviews, testing, and monitoring are part of our craft—not the exception.

  • In solution design, we work closely with the business analysts because we don’t just want to write code—we want to understand why it’s written that way.

  • By using Angular in a micro-frontend architecture, we ensure that each extension remains isolated and every change remains manageable.

  • We don’t limit ourselves to UI components; instead, we understand how the front end interacts with backend processes and the BPMN engine.

  • We configure custom UI components directly and deploy them immediately, working closely with the product and the customer.

  • We work closely with business analysts. We implement their designs in a way that ensures they work effectively and feel intuitive.

  • Test strategies are developed early on and in close collaboration with the analysis and development teams.

  • Test automation: We develop automated test suites that catch errors before they go live. Various environments are available for testing (e.g., Dev, Test, Pre-Prod). In addition, systems are available to cover other aspects of testing (LTS releases, performance, migration, etc.).

  • Manual & Exploratory Testing: At the same time, our manual testing team ensures in-depth coverage. Through targeted manual testing and exploratory approaches, we examine complex scenarios and the user experience that purely automated processes cannot capture.

  • Understanding insurance logic is a prerequisite for us: Insurance processes have specific edge cases and exceptions that can only be tested if you understand them.

Having a dedicated testing team in a company of our size is a testament to our commitment to software quality. Furthermore, quality standards are not only embedded within the testing team but are established throughout the entire development process.

  • We continuously operate and develop our Kubernetes clusters. They are highly available, scalable, resilient, and cloud-agnostic.
  • We implement and operate GitOps with Argo CD in a way that ensures deployments are automated, versioned, and traceable at all times.
  • We build CI/CD pipelines using Jenkins, Helm, Go, and Taskfile, and test them with a Go testing framework in dedicated test clusters.
  • With our monitoring stack consisting of Grafana, Prometheus, Loki, and Alloy, we ensure that issues are detected before they impact operations.
  • We don’t view security and administration as add-ons, but as an integral part of the architecture—because in the insurance industry, there’s no room for compromise in this area.
Stefan - Senior Software Platform Engineer

These days, the 10% code portion can almost be automated. We’re looking for engineers to handle the 90% of the brainwork behind it—people who aren’t narrow-minded, but who consider the impact their work has on the bigger picture.

Stefan
Senior Software Developer

Marc - Software Architect

We don't build an off-the-shelf framework—we build a powerful system. Since every customer has their own processes, solution design at our company is more challenging and exciting than with traditional SaaS solutions.

Marc
Software Architect

Julian - QA Manager

Our testers shouldn't just focus on their test cases; they should look around, identify opportunities for improvement, and suggest them. At our company, the team has the freedom and space to do just that.

Julian
QA Manager

Moritz Ops Engineer

Kubernetes, Linux, security, and automation are the hard skills. But what truly sets us apart as a team is our role as an interface within the company. Anyone who can’t think across teams will quickly realize that even the best cluster setup is useless.

Moritz
Ops/DevSecOps Engineer


Join Our Team

You don't just develop features—you help shape the platform on which tomorrow's insurers will work.

OPEN

Open Positions – Engineering at tech11

Unsolicited Application

Würzburg (Bavaria, Germany) Full-time Permanent position

Senior IT Business Analyst, Insurance (m/f/d)

Vienna (Austria) Full-time Permanent position

Classic Enterprise vs. tech11

Requirements are being implemented

Part of the solution design, from architecture to implementation

The tech stack is set; changes take years

Modern technologies are constantly evolving

Domain logic is the responsibility of the business, not the technical side

For us, insurance logic isn't just a business issue; even engineers understand the context behind the code

Front-end, back-end, and operations teams work in silos

Micro-frontend architecture, the BPMN process engine, and the CI/CD pipeline are all part of our overall picture

Testing does not accompany development throughout the entire process

Quality is achieved through reviews, testing, and staging

Decision-making processes are lengthy and political.

Decisions are made on an equal footing and implemented immediately

Claudia

Does our

work style

suit you?

You'll thrive here if …
  • you don't just process tickets, but want to understand how your solution affects the overall system.

  • you find solution design just as exciting as the actual implementation.

  • you don't view technical complexity as a hindrance, but rather as part of the task.

  • you don't view quality as an obligation, but as an attitude that is reflected in code reviews, testing, and monitoring.

  • you evaluate technologies based on their usefulness, not on the hype surrounding them.

  • you value cross-team collaboration, bringing together Business, Quality Assurance, Operations, Frontend, and Backend teams.

Probably not your type if …
  • you'd rather process tickets than make decisions.

  • you're not interested in technical depth or insurance logic, because good solution design isn't possible without context.

  • you're working with blinders on and don't want to step outside your comfort zone.

  • you prefer a highly standardized, well-established enterprise environment.

  • you feel more stressed by rapid shifts in direction and expanding structures rather than energized by them.


Tech Stack FAQs

Just how modern is our tech stack, really?

Our tech stack isn’t a stagnant, legacy system—it’s a system in constant evolution. Quarkus instead of a traditional application server, cloud-native instead of traditional deployment, and LLMs used pragmatically where they deliver real value. We ’re helping shape what tomorrow’s platform will look like.

What exactly is used on the backend?
    • Java 21 with Quarkus as its technological core

    • BPMN 2.0 in CIB Seven (an open-source fork of Camunda) for the process engine

    • Kubernetes for container orchestration

    • Argo CD for GitOps deployments

Java skills are the foundation; everything else comes with the job.

What's the idea behind your micro-frontend architecture?

Individual modules are isolated and extensible. Custom UI components can be configured directly without affecting the core system. Our tools:

    • Angular, TypeScript, HTML, and CSS for module development

    • lit-html for components in the existing system

What tech stack can I expect to work with on the OPS team?

Linux and IT security form the foundation. Building on that, we use:

    • Kubernetes (Cluster API, Hetzner Cloud) for cluster management

    • Argo CD for GitOps

    • Jenkins for CI/CD pipelines

    • Helm for deployments

    • Go and Taskfile for automation

    • Grafana for monitoring

What can I expect on the QA team?
    • X-Ray as a central test management tool, which reduces mapping overhead

    • Jenkins for automated test executions and CI/CD integration

    • Selenium/Selenide in Java for test automation

Do you have freedom of choice when it comes to technology, or is everything predetermined?

We have a defined tech stack, but we don't have blinders on. Whether it's Linux or Mac, IntelliJ or alternative IDEs: Everyone chooses their own setup based on what maximizes their productivity. New technologies and architectural ideas are discussed, not shut down.

Team Image
Michelle Lewis
Web Developer

Indise takes into account even smooth and responsive...

Team Image
Lucia Stuart
Web Developer

Indise takes into account even smooth and responsive...

Team Image
Michael Shadix
Web Developer

Indise takes into account even smooth and responsive...