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
Re-Submitting Binary Dead Letter Queue Messages for Azure Service Bus
There are two interfaces for the Azure Service Bus. One is a Windows application called ServiceBusExplorer, originally developed for the Windows Service Bus. The other is the Azure ServiceBusExplorer, a web interface in Azure DevOps modelled on the original ServiceBusExplorer. Both interfaces allow individual messages in a dead letter queue to be re-sent. If the message is binary-encoded (e.g. via Protobuf), it is interpreted as text and thus rendered unusable. The task of the project was to extend both interfaces to enable the re-sending of individual messages.
- Reproduction of the problem in a simple example
- Creation of the feature request for the Azure ServiceBusExplorer
- Creating and discussing the issue for ServiceBusExplorer
- Implementing a solution for ServiceBusExplorer
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
Monitoring for Business Applications
The goal of the project was to make normal cloud operations visible to employees. In the existing systems, developers were frequently asked to check whether the system was still running correctly. The task was, on the one hand, to make it visible that the system was running correctly and, on the other hand, to detect problems quickly enough that they were resolved before being reported as errors.
- Evaluation of OpenTelemetry and OpenTracing
- Design and development of a tracing solution for asynchronous communication via business events
- Embedding domain-specific metrics in C#
- Creating dashboards in Grafana
- Configuring alerting and fine-tuning thresholds
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
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
Persistence Problems
The newly introduced Continuous Delivery pipelines exposed non-reproducible persistence problems. Distributed transactions could not be completed under load. Since Schleupen.CS 3.0 has only a single database, no distributed transactions should have occurred at all. The task of the project was to analyze and resolve these problems.
- Analysis of log entries, error messages, and code to systematically narrow down the issue
- Analysis of NHibernate and its internal handling of transactions
- Concept and implementation of a clean but complex solution for new applications
- Concept and implementation of a quick but somewhat hacky solution for existing applications
- Documentation of both solutions
- Training sessions on the solutions
- Implementation of the clean solution in the platform components
Legacy Pub-Sub Solution
To comply with legal requirements for smart meters (intelligent electricity meters), it was necessary to establish a communication solution between Schleupen.CS 2.0 and 3.0. This had originally been excluded from the initial architecture but became necessary for business reasons.
- Concept for asynchronous communication between separate systems
- Mapping Pub/Sub queues in a database
- Implementation of generic receiver and sender solutions
Stabilization of Asynchronous Communication – Business Components
When distributed systems communicate asynchronously and messages are lost, it is very difficult to find out where they go missing. Since the previous project had shown that the errors were no longer in the platform components, the team's task was to provide solutions within the framework to support the business developers.
- Concept and implementation of the Transaction Outbox Pattern in the framework
- Documentation of the Transaction Outbox Pattern
- Training sessions on idempotency and the Transaction Outbox Pattern
Stabilization of Asynchronous Communication – Platform
When distributed systems communicate asynchronously and messages are lost, it is very difficult to find out where they go missing. The task of the project was to analyze the existing code and identify and fix weaknesses in the platform components. Solutions were also developed to increase the confidence of testers and developers in the platform components.
- Concept and implementation of the Test Message Pattern
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
Billing
Ferber-Software is the market leader in Germany with its debt collection software IKAROS. As part of the IKAROS V4 project, various modules were modernized. The billing module involved extracting existing business logic from the MsSQL database and migrating it into a business logic layer.
- Analysis of existing T-SQL stored procedures and mapping the logic to C#
- Design and implementation of the new business logic layer
- Data modelling and mapping using NHibernate
- Optimisation of database queries to ensure performance during billing runs
Consulting for Debt Collection Companies
Ferber-Software is the market leader in Germany with its debt collection software IKAROS. IKAROS has its own programming language that can be used to customise the software. Adaptations are also implemented via import and export interfaces. Consultants carry out these customisations on-site at the client.
- Program for importing and exporting claims data of a passenger rights portal from one debt collection software to another
- Coordination and clarification of requirements with the client
- Training of consultants in software development with C#
Marketplace for Debt Collection Field Agents
Design and implementation of a B2B web portal as a marketplace solution for receivables management. The system enables debt collection companies to submit claims digitally, which are automatically assigned to freelance field agents for on-site contact. The platform acts as an efficient, private-sector alternative to traditional bailiff services and optimizes the process chain between back-office and mobile field staff.
- Full-stack development of the portal and the underlying business logic
- Implementation of import interfaces for automated transfer of claims data
- Implementation of an export functionality for billing documents (invoices)
- Multiple manual deployments of the web portal
- Analysis of penetration test results and consultation on deriving action strategies
- Ongoing further development and technical and functional support of the marketplace after the initial release