Backend Developer messaging platform – IT Operations (Dutch only)

What you'll do

You will work in a team where the focus lies on:

Building reliable backend services in a microservice-like, event-driven architecture;
Cleaning up the domain and creating clear responsibilities per context;
Capturing behavior in tests, so that requirements are demonstrable;
Building secure, scalable, and manageable solutions in Azure and Kubernetes;
Continuing the development of the solution toward a domain within PFS after ROB.

As a backend developer, you will work in a DevOps team and be involved from the first idea through to realization, further development, and management. You don't just build features, but also think along about solutions that truly work in practice and that are also easy to maintain in the future.

You develop backend services in C#/.NET for various components within ROB, such as inbound and outbound communication, target group determination, routing, dispatch, tracking, and operational flows. You work according to a clear architecture with explicit boundaries and individual responsibilities.

You do this in an environment where the basic principles are:

Event-driven microservices with clear responsibility per bounded context;
Clean and hexagonal architecture, where domain logic is separate from infrastructure;
Robustness and scalability in Azure and Kubernetes;
Executable tests as part of the development process, not as a check afterwards.

You work from concrete requirements and translate them into a clear technical design. Where necessary, you make interdependencies explicit, so that the software not only works but also remains testable and maintainable.

Within ROB, it is essential that software not only functions but also demonstrably meets the agreed specifications. Therefore, you work from clear, concretely formulated requirements and capture behavior in tests.

You contribute to:

Good analysis of business rules and domain concepts;
The formulation of concrete acceptance criteria;
The conversion of these criteria into positive and negative test scenarios;
Monitoring consistency between requirements, implementation, and tests;
Enforcing quality through unit, integration, contract, and acceptance tests.

You have an eye for the difference between "it works in my environment" and "it works according to the agreed specification." For you, the cohesion between requirements, code, and tests is a requirement.

You work on quality, testability, and operational reliability

You understand that software is only good once it can run securely, maintainably, and in a controlled manner in production. Therefore, you are aware of:

Test strategy and quality in the entire development pipeline;
Setting up CI/CD and quality gates;
Security-by-design and privacy-by-design;
Data minimization, auditability, and logging without personal data and test data in logs;
Monitoring, observability, retry, fallback, and rollback behavior;
Kubernetes, cloud infrastructure, and operational robustness.

You therefore work not only on functionality but also on the sustainability of the software in production. You contribute to a development environment in which quality is monitored throughout the entire process, not just at the end of a sprint.

You are interested in the principles of domain modeling, semantic boundaries, clear responsibilities, and translating business rules into software.

You want to know why something belongs in a certain context, and you are prepared to determine the correct boundaries together with colleagues and architects. You are curious about the "why" of a design, not just the "how."

In the ROB domain, the focus lies on issues such as:

How do we keep the domain clear, testable, and manageable in an event-driven microservice environment?
How do we ensure that integrations, authorization, observability, and monitoring are correct and robust?
How do we create software that not only works but also demonstrably meets the agreed specifications?

You build solutions that contribute to a safer, better-working, and better-controllable environment for operations. After ROB, you can transition to a domain in PFS, where the same starting point applies: software that works in practice, is secure, is well-researched and tested, and is ready for further growth.

You have a solid foundation as a backend developer and are well able to split complex problem situations into clear software solutions. You are used to working in a modern DevOps environment and understand how technology adds value to the business.

You look beyond just the code:

You think from the perspective of the user and the practice in operations;
You test and validate your solutions against actual usage;
Collaboration comes naturally to you. You actively seek connection with colleagues and stakeholders and feel co-responsible for the result;
You take ownership, are curious, and are continuously looking for how things can be improved;
You like working in a data-driven way or want to develop yourself further in this;
You follow new developments within the field and are motivated to apply this knowledge where it adds value.

With ROB and in the further development toward PFS, software must not only be built but also proven. The developer we are looking for can therefore not only write code but must also be able to work according to the fixed standard that:

requirements are translated into concrete, testable specifications;
behavior is captured in tests, including positive and negative paths;
code is only considered finished when it is working and sufficiently tested;
quality, reliability, and security are part of the development process, not a separate chapter at the end;
a change can be substantiated with tests and not just with "it works on my machine".

The same mindset applies to moving into a domain within PFS: clear specifications, testable software, and demonstrable quality are a fixed foundation for every team member.

We value an attitude in which you:

are open to feedback;
collaborate with product, operations, architecture, and other developers;
take responsibility for your work and for the result of the team;
keep improving and look for better solutions;
are capable of translating complex issues step by step into workable and testable software.