PaedNet (part of Schulportal Hessen)
PaedNet is used within the local school network. It serves the administration of computers in the computer lab and the management of teaching scenarios with school-owned devices. The software enables, among other things, the central control of computers in the classroom (monitor lock, internet lock), the automated distribution and collection of files, the installation and updating of software on all school computers, and the generation of standardized code snippets with AI.
- Architecture redesign for existing software
- Modernization of existing software
- Code refactoring with a focus on maintainability
- Introduction of current standards (Logging, Dependency Injection)
- Training in best practices of the standards
- Establishing automated tests
- Teaching agile concepts (requirements refinement, regular reviews)
- Consulting and designing pragmatic solution approaches to reduce technical complexity
DIVID, die Einwegkunststofffonds-Plattform
The DIVID project is the digital platform of the Federal Environment Agency (UBA) for implementing the Single-Use Plastics Fund Act (EWKFondsG), through which Germany has transposed the extended producer responsibility under the EU Single-Use Plastics Directive into national law. The platform serves as the central point of contact for manufacturers, municipalities, and other eligible parties. Manufacturers of single-use plastic products are thereby involved in the costs of cleaning, collection, and disposal. The DIVID platform is developed iteratively on the basis of a modern technology stack with the guiding principles of modularity, microservices, and API-First, and enables the required digital processing of all processes from manufacturer registration and quantity reporting through to fund management and payment settlement for eligible groups.
- Merging functionally related microservices
- Automated data migration of distributed databases into a common schema
- Adaptation of the API Gateway
- Creating the CI pipeline in Azure DevOps
- Configuring code coverage measurement
- Rolling out SonarQube in an IaC pipeline
Application Monitoring
cover.mesh had an existing application in which insurance data was stored. The goal of the project was the real-time capture of data changes in the new back-office service, including a graphical presentation as time-series analysis in an interactive web dashboard.
- Implementation of event sending within the persistence layer
- Configuration and integration of Azure Event Hub
- Development of a reliable messaging logic (at-least-once delivery)
- Implementation of the time-series calculation
- Building the web portal with Blazor Server Pages
- Development of dynamic bar charts for displaying time-series analyses
- Creating the CI/CD pipeline in Azure DevOps
Insurance Calculation for Nursing Homes
cover.mesh is part of the SCHUNCK GROUP and develops digital solutions for it. The SCHUNCK GROUP is a company of the Ecclesia Group and the largest German insurance broker for businesses and institutions. The task of the project was to provide a web platform that performs calculations based on domain-specific rules.
- Building the web portal with Blazor Server Pages
- Creating the CI/CD pipeline in Azure DevOps
- Implementation of the business logic
Self-Service Payment Portal
Lowell had already implemented an online payment option via the consumer portal. However, since the registration process for the portal was complex and involved sending a letter, management wanted straightforward solutions for paying claims directly online. Within the project, several options were developed and implemented.
- Designing solutions together with the managing director
- Implementation of three concepts (Self-Service Payment Portal with postal code, payment link sent in the welcome letter, ad-hoc payment link for callers)
- Monitoring of collected payments
- Privacy-compliant design of the Self-Service Payment Portal
cLean – Debt Collection Software
With the cLean project, Lowell pursued the development of a unified debt collection software for all group companies. All claims of the DACH organization were to be processed as automatically as possible in a highly available system. A key focus was determining the possible scalability of the system at certain times when large volumes of claims had to be imported. C# was the primary programming language, but individual services were implemented in Kotlin and Go.
- Architecture of the microservices system
- Defining service boundaries along business domain lines (DDD)
- Partitioning data into aggregates
- Concept and design of a case reference number readable by both humans and machines
- Concept for an immutable accounting system using Event Sourcing
- Concept and implementation of the accounting component in compliance with business rules
- Research into settlement logic in Germany and Austria
- Implementation of business logic
- Realization of search queries across distributed systems (separate service using CQRS)
- Cross-team coaching, training, and support
Central File Service
Lowell processes many documents — scanned letters, legal documents, evidence of claims, and files from consumers. The goal of the project was to provide a central file service capable of storing and serving large volumes of unstructured documents in an audit-proof manner.
- Concept and implementation of the file service, including deciding how to store metadata
- Design of the gRPC API
- Upload and download functionality in the gateway to the consumer portal
- Extension of the file service with MIME type support (required for downloads)
API-First
Lowell follows an API-First strategy. The goal was to make the API available to external processes as well. To this end, a central API was provided fully automatically and used by all services. The API is subject to strict guidelines regarding design and backwards and/or forwards compatibility depending on the use case.
- Concept and creation of a central API-First repository based on Protobuf
- Automated generation of release and pre-release versions for multiple programming languages to optimize development speed
- Concept for API versioning
- Creating APIs
- Documentation of the API
- Reviewing APIs with a primary focus on clarity, documentation, and breaking changes
Migration of an On-Premise Kubernetes Cluster to Azure Cloud
Initially, services were operated in an on-premise Kubernetes cluster. The goal of the project was to migrate all services to Azure Cloud. Additionally, technologies and cloud services were evaluated, utility classes and templates were created for future development, and a CI/CD pipeline was established.
- Selection of cloud services to be used in coordination with the architect
- Agreements on future autonomy of development teams
- Review of existing code and resulting best practices
- Documentation of the Transaction Outbox Pattern, idempotency, aggregates, and other useful microservice patterns
- Utility classes for sending and receiving Protobuf business events
- Creation of the CI part of the CI/CD pipeline
- Evaluation and implementation of Azure Serverless
- Setting up infrastructure using Infrastructure as Code (IaC)
- Liveness check / readiness check for services in Kubernetes
- Creation of cron jobs in Kubernetes
- Creation of C# templates for building new services
Caller Verification
Consumers can call Lowell. At peak times, call volumes reach one call every two seconds. In collaboration with a provider of IVR systems (Interactive Voice Response), a system was created in which callers automatically verify themselves using their case reference number and personal data. After successful verification, they are transferred to a case worker, whose system automatically opens the correct file. The project focus was on the highest possible availability, as outages would have caused significant additional workload for case workers.
- Onboarding new Lowell subsidiaries
- Adaptations and extensions of the interfaces
- Definition of the API with a focus on compatibility
- Communication of the API to third-party providers
- Testing the interface locally, in the CI build, and in production (partially semi-automated)
- Rolling out the API with zero downtime in a Kubernetes cluster
- Analysis and resolution of production errors based on log entries
- Analysis of connection issues in the Akka.NET code
- Monitoring of incoming calls
Claim Data for the Consumer Portal
Lowell's consumer portal is a central digital service platform for individuals with outstanding claims at the debt collection agency. Lowell consists of multiple companies that are separated both organizationally and technically. Several different debt collection software systems had to be mapped onto a single API.
- Onboarding new Lowell subsidiaries
- Adaptations and extensions of the interfaces
- Definition of the API with a focus on compatibility
- Testing the interface locally, in the CI build, and in production (partially semi-automated)
- Rolling out the API with zero downtime in a Kubernetes cluster
- Analysis and resolution of production errors
- Reduction of the number of services, as the microservices had been cut too small
- Fixing security vulnerabilities and hardening API interfaces after penetration tests
- Guiding the development team to sustainably avoid identified weaknesses
- Defending the system architecture against external security auditors
Schleupen.CS 3.0 – Architecture and Framework
The Schleupen.CS software solution is a distributed application with numerous functional and technical components, aimed at providing a standardized and configurable software solution for the energy and water sector across different market roles. The "Architecture and Framework" team works directly with the enterprise architect and handles all cross-cutting concerns of the backend. The team's tasks involve creating cross-team best practices, design patterns, and a framework for over 100 developers, so that the architecture is implemented as consistently as possible across the many different applications.
- Development and consolidation of the application architecture
- Reducing dependencies between teams through better modularization of the framework
- Development of SOAP services for platform components
- Analysis, design, and implementation of a new deployment solution based on Puppet
- Writing and automating CoffeeScript (a JavaScript dialect) unit tests
Case and Process Window
Greenfield development of the central workspace of the debt collection software (IKAROS V4). The project encompassed the redesign of the case and process window to display complex case information in a clear and performant way. By using Event Sourcing, a modern and auditable data storage approach was realised for the processing steps. The efficient loading of events required optimised data loading logic.
- Implementation of the process window view
- Implementation of the business logic for displaying processes
- Calling and displaying values from the claim calculation and claim statement
- Performance optimization of data queries through highly efficient SQL queries (bypassing NHibernate to maximize loading speed)
- Ensuring functionality through automated tests (unit tests)
Responsibility for Automated Testing
A strategic project to improve software quality across all product areas. The goal was the company-wide standardisation of testing practices to increase the stability of night builds and detect regressions early. This included both technical adaptations and knowledge transfer within the development department.
- Leading by example
- Company-wide establishment of best practices for test automation
- Agreeing on test coverage targets with testers
- Training sessions on performing unit tests and patterns
- Analysis of failed tests in the night build (e.g. during daylight saving time transitions)
Claim Statement
A claim statement is a detailed, tabular listing of all outstanding amounts (claims, interest, fees) that a creditor demands from a debtor. The data is provided by the claim calculation engine. The debtor can request a claim statement at any time, and this must be generated by IKAROS in a legally compliant manner.
- Extension of the claim calculation to capture individual calculation steps
- Implementation of the claim statement
- Outputting the calculation in a Word document
- Agreeing on concrete test cases with domain colleagues
- Creation of automated tests for the claim statement
- Writing tests for defects and subsequently fixing them