Daniël Koek

At Uniphar I work in the Platform Engineering team. Together we build and maintain the shared services that every other product team depends on to move data and files reliably through the organisation. Rather than owning a single product, we look after a whole set of platform components — a Kubernetes ingress controller, a message broker monitoring platform, a Teams notification API, and FrontGate, the company's file onboarding and processing solution — and I move between them wherever I am needed most. Across all of these the focus is the same: reliable, observable services on modern .NET (currently .NET 10) running on AKS, with a strong emphasis on OpenTelemetry so issues surface before they become incidents.

The main tasks I had at Uniphar were:

• Contributing to FrontGate, the company's onboarding and file processing solution, adding new ingestion connectors, fixing production issues and migrating its Kubernetes ingress handling onto a custom AbstractIngress CRD
• Building and maintaining the message broker monitoring platform, which watches Azure Service Bus queues and Logic Apps/Integration Suite for failures and surfaces them proactively in Teams
• Developing the Teams Notifications API, which provisions Teams apps and posts interactive cards (reprocess/view-file actions) back into channels
• Working on IngressProcessor, the AKS controller that injects Kubernetes ingress configuration into Azure Front Door, including designing the AbstractIngress CRD now shared across other platform services
• Building a ServiceNow integration API for creating and managing incidents, and a SAP event ingestion service that sinks events into Azure Data Explorer
• Contributing to shared platform building blocks: the Uniphar.Platform.Telemetry NuGet package, the Document API, DotFlyer (SMS/email sending) and the pod notes controller used for AKS image cleanup
• Rolling out OpenTelemetry, health probes and shared CI/CD workflow conventions across these services, and tightening workflow permissions as part of a broader security hardening effort

Kiwa asked me back — not for the project I was originally hired for, but to give some of their internal systems the TLC they needed. Alongside day-to-day maintenance and new features, I drove a migration from .NET Framework to .NET Core: with minimal effort I removed the dependencies that were blocking the switch and successfully migrated the application. Because I learn a new system inside out very quickly, I also became the go-to person for a number of older applications nobody in the company had knowledge of anymore, and I wrote the documentation that was missing.

The main tasks I had at Kiwa were:

• Maintaining and extending the internal line-of-business applications
• Fixing bugs, building new features and finding bugs before users did
• Cleaning up legacy code, upgrading projects and designing upgrade paths (.NET Framework to .NET Core)
• Helping build an invoice proposal system
• Reverse-engineering undocumented systems and making them maintainable again

When I joined Vicrea, the application was a proof of concept running on local Portainer instances, with little consideration for reliability, security or isolation of business logic. My main task was to get a production-ready application launched. Leveraging my years of experience across software stacks, I turned it into a cloud-native application with the observability you would expect of any modern system. Along the way we removed every manual step — new customer environments are provisioned fully automatically — and made sure the application could handle large amounts of geo-data without incurring a large cost to the company.

The main tasks I had at Vicrea were:

• Creating CI/CD pipelines to automatically deploy new versions of microservices (leveraging helm)
• Isolating the FE from the BE and deploying this using Cloudflare workers in order to have a serverless global low latency way to serve HTML/CSS/JS
• Building logic so that part of the FE was only available for authenticated users
• Automatically using infrastructure as code to provision new environments, including databases, docker registries and k8s clusters
• Refactoring major parts of the existing code to be compliant with Domain Driven Design concepts
• Creating background processes that would pull large datasets from various government agencies. This was then redistributed to various internal APIs, which in turn would provide insights for users
• Removing FE-microservices and creating a mono FE, refactored from single-spa to Remix, introducing Tailwind and moving from Leaflet to OpenLayers
• Mentoring/teaching other developers in kubernetes and how to develop decoupled software

Kiwa tasked us with building a proxy-type application to collect and process data for the manure industry. The system had to be asynchronous, reliable, secure and highly flexible, so we chose containers and Kubernetes — and since I had previous experience there, I designed and set up the foundation of the system. We picked Kafka as the pub-sub backbone for its reliability and Elasticsearch for logging, and built an API-driven front end using utility CSS and Web Components to keep that side just as flexible and scalable. We even built our own OAuth server due to the constraints presented to us. It was the first time I built everything from scratch, and the project proved that 'new' technologies are not just worth it — they are highly flexible and maintainable when done right.

The main tasks I had at Kiwa were:

• Designing, building and implementing the infrastructure from scratch
• Introducing container technologies to a company that still ran servers on bare metal and had no prior history with Docker
• Building backend services (with full CI/CD) to process SOAP, XML and SFTP, exposed through RESTful APIs for a very flexible way to insert and collect data
• Creating a dynamic, data-driven front end — table-heavy screens that had to stay readable, responsive and flexible for future changes
• Creating a full OAuth flow with multiple login systems and roles maintainable from the front end, including a "Permission Module" uniquely developed for the agriculture market but customisable for future portals
• Improving security end to end: Cloudflare Tunnels, E2E HTTPS traffic and a zero-trust security plan with higher standards than any company I had encountered before

When I started at Univé, a lot of older techniques were still in use — jQuery among them — which, combined with hard-to-read code, slowed every developer down. I introduced Web Components (LitElement) together with Tailwind's utility-based CSS, which made the team quicker and more productive without changing too much of the existing workflow, while dramatically shrinking both the JavaScript and CSS on new components. To make it all easier to manage I also brought in Karma for unit testing and Storybook as a component library, so UX could review components at an earlier stage and we all had a better view of what lived where. Together this let us build a more powerful user experience while keeping a consistent look and feel.

The main tasks I had at Univé were:

• Maintaining unive.nl and its logged-in environment
• Introducing new technologies tailored to the product and bringing them to production (Tailwind, LitElement)
• Maintaining and improving build and release pipelines for quicker builds and better stability
• Building new features that still gave a rich user experience despite limited availability of surrounding systems — finding creative solutions rather than being limited by systems outside our control
• Being a helping hand for other team members when they got stuck building new or improving existing code

RTL has loads of systems that need to communicate with each other. We built a data hub that funnels a few source systems into multiple target systems, reducing load and making it possible to integrate legacy systems with the newer platforms RTL acquired. The data ultimately serves as metadata for platforms like RTL XL and Videoland.

The main tasks I had at RTL were:

• Receiving and adapting data from the source systems
• Creating distributors that fan the data out to four target systems, each tailored to that system's needs
• Building the CI/CD pipeline in Azure DevOps and setting up Azure resources
• Guiding the team as team lead: introducing Kanban and gathering business requirements from the product owners

MyDataFactory is a company that specialises in building matching engines for customers that have invoices coming in from different sources and that want to match this to their own in-house catalogue of products. Through the process of manual and automated tagging of potential products, the user can decide what products with what items on the bill, after which the system will improve itself to remove further human intervention.

The main tasks I had at MyDataFactory were:

• Building the front end where matches are suggested, approved and — after processing — downloaded for other systems
• Building and deploying a proof of concept moving the entire infrastructure to Kubernetes as infrastructure-as-code, automated with Helm
• Consolidating the existing tag structure into a single system with deep-dive tests to guarantee tag behaviour now and in the future
• Migrating Azure Functions to Kubernetes pods consuming from Kafka, which improved performance significantly, with results stored in Elasticsearch

PFM creates reporting, data repair and data collection software to measure footfall (visitors). The old stack had to be phased out, so together with the development team I rebuilt its functionality in .NET Core and Angular — with many improvements and optimisations, partly by improving the data flow and partly by cutting cost through serverless approaches like AWS Lambda.

The main tasks I had at PFM were:

• Building new front end functionality and refactoring existing Angular code
• Creating Lambdas that consume Kinesis events from field sensors, parsing, processing and validating the data before storage

We built a fact/score-based fraud prevention system that determines whether a transaction sent by a customer belongs to a legitimate person: let the good guys in, make it very hard for the bad guys, using aggregation over big data sets to identify users based on their history.

The main tasks I had at TransUnion were:

• Integrating third-party data sources (XML, SOAP, JSON and custom formats) for better fact results
• Extending the existing APIs and surfacing them in a VueJS demo application
• Creating test and mock systems for better QA automation
• Improving delivery pipelines to speed up releases and remove manual steps
• Building custom NiFi processors for handling data streams
• Taking part in the on-call rota for outages, remotely diagnosing why systems went down or consumed excessive resources

Full stack development on a medical record system used by nearly all cruise ships. Strictly monitored by coast guards: no record can ever be deleted and everything follows comprehensive guidelines. Worked directly with clients on issues and new enhancements.

Testing Apple software products, raising bug tickets and language proofing Dutch translations.

Rapid prototyping consultant, building experimental prototypes for third-party clients: a model taxi parking system for KLM at Schiphol, a gamified Apple Watch health app for Interpolis, and an offline-capable evacuation app for ProRail (Dutch railroad infrastructure).