Andreas Maier

Own product: SaaS platform for German-speaking congregations for automated transcription, translation and thematic analysis of sermons. End-to-end responsibility from product idea through architecture to production operation.

In the customer's enterprise environment (>100 microservices) it is essential to implement live monitoring of critical business processes. The classic stack of Prometheus and Grafana was chosen alongside AppDynamics and Azure Monitoring.

Metrics were determined and exported to Prometheus using both whitebox and blackbox testing.

My task was the implementation of blackbox tests with Playwright, briefing teams on structured delivery of metrics via the Prometheus API, and supporting the CI/CD process for automatic deployment of Grafana dashboards.

As part of the migration of software systems from a legacy architecture to microservices in Quarkus, there is a high demand for training. With the simultaneous introduction of Camunda, Kafka, OpenShift, Docker, programming with Apache Camel and the consistent use of Quarkus for microservices, several PoC implementations as well as training materials and tasks are required.

My task was to carry out various PoCs – independently or with a small team. Creating training scenarios and training employees were further tasks.

The client purchased standard software for various areas (contract management, partner management, customer accounting). The task was to integrate contracts for a new business line into the new contract management system and to migrate existing data.

I was responsible for analysing the enterprise architecture consisting of various software components (COBOL core system, Java modules, third-party software), understanding the existing interactions from a business perspective and adapting them for the integration of the new software.

The new interfaces via Apache Kafka, REST and SOAP had to be modelled precisely so that external software developers as well as internal developers had exact specifications.

The client was a major credit card processor for travel expense management.

The requirement was the creation of virtual credit cards that can be created, blocked and archived according to complex business specifications.

Communication with OEMs and payment providers was necessary.

My task was to extend the existing architecture and supplement it with the new business requirements.

In addition, it was necessary to adapt the architecture to the new requirements, create new services, perform code migrations, and integrate into both the software development process and the CI/CD process.

The objective of the project was to migrate an existing software architecture – built with Elasticsearch and manual services – to a streaming architecture.

Raw vessel data was to be transferred from an input topic to further partitioned topics. From there, knowledge extractions could be performed for registered customers. Since the vessel data was already partitioned, higher scaling through replicas was possible.

My responsibility was to select and install/provision a suitable Apache Kafka setup. The requirement was hosting on Amazon AWS using the MSK service.

In addition, I was responsible for the implementation of the microservices themselves and for the integration into the existing CI/CD system with GitLab and for operations on Digital Ocean in managed Kubernetes.

As part of the software development process for a credit card provider, it was necessary to maintain a release tool that manages the preparation of a release across multiple, partly interdependent microservices.

Integration with Jira as a data source was required. This was used to create an overview of the overall release in Confluence, assign release numbers and hand over to test management and rollout.

For a large banking services provider, the challenge was to migrate from a centralised architecture to a decentralised one. Several projects were set up to compare different messaging stacks with Kafka and also to analyse stream processing for specific business use cases.

My task in this project was to train and coach employees on Apache Kafka functionality. Various questions had to be clarified – including the volume of future events and the required resources, the performance of different stacks (Confluent) and their feature breadth, as well as logging and monitoring.

A performance measurement for transaction queries was also implemented using stream processing. This was measured with a Spring Boot microservice and timestamps were forwarded to an Elastic (ELK) stack, where the timing was displayed and presented to stakeholders.

To extend the core banking software, the integration layer was defined and built. It consists of the messaging system Apache Kafka, Spring Boot services running in an OpenShift cluster. My involvement in the project included consulting, implementation and execution of tasks:

Development

To decouple the microservices from the ERP system, it was necessary to implement Kafka. The task was to install Kafka on the Kubernetes cluster in a suitable and customised installation.

A Kafka adapter was then built that is called event-dependently and pushes changes to articles, prices, images or customers to the respective topics.

Order data retrieved from third-party systems was to be imported into JTL Wawi. An import tool (Ameise.exe) was wrapped via Java and the import as well as command line output was returned via REST.

The challenge was to deliver data in a system-specific manner. Categories had to be presented in a recursive tree structure, image data resized on demand, and attributes for articles and styles managed accordingly.

To achieve the required delivery performance, a Redis cache was placed in front of the interfaces, allowing large requests to be answered very quickly.

The complete card processing was mapped in the mediation layer as SAP's performance was insufficient. It was also not possible to store open-to-buy and limit structures hierarchically. This requirement existed because a company account credit card has limits at different levels.

Apache Kafka served as the exchange mechanism for the services. It was necessary to provide training and support both in operations and during service integration – this was also part of my responsibilities.

The task in this project was to provide the ideal infrastructure for a TV broadcast with at least 100,000 simultaneous users.

The fashion startup was expanding rapidly. In this context, an ERP software had to be introduced that met the customer's requirements. As part of this project, a business process analysis was carried out to select a provider, resulting in a short/long list for vendor communication.

The right software was selected through a pitch process.

During implementation, technical adjustments were required. The import of product data, customer data and previous order data had to be organised and executed. In addition, the logistics process for shipping had to be defined and implemented.

Building a web presence with an integrated e-commerce webshop based on the founders' vision.

Requirements included design specifications and functional requirements that had to be specifically adapted.

A WooCommerce installation was taken as the base and extended. Git versioning was introduced, providing real-time Slack notifications on changes.

Functional adjustments were required for switching campaigns.

Example: Above a certain cart value, products are automatically added.

The technical responsibility included migrating the entire site from conventional hosting to Amazon Web Services. A cloud ERP system and payment providers were integrated. Production exports had to be generated from the product data.

As part of the further development of the customer sales portal, changes to the existing architecture were necessary. The goal of the transformation was to enable the existing functionality on mobile devices.

In a banking application, legal requirements had to be implemented. This specifically concerned the adaptation of the credit process. Associated partners connected to the credit process had to receive new data. The extension including E2E tests was taken on. In addition, it was necessary to technically adapt many sub-processes such as credit decision checks, model calculations, and collateral. When extending services, models had to be adapted and classes generated accordingly.

Building a behaviour-driven testing implementation and execution environment for a new section of the portal. Supporting and advising the quality assurance team on performance, SEO and tracking testing. Suitable tools and processes were evaluated and introduced.

Tasks within this sub-project included capacity planning within the team, requesting resources, planning milestones and demands for various requirements from operations and specialist departments. Further tasks included accepting implemented functions and transferring them to the test centre, reporting and status updates to the main project lead, as well as budget planning and requesting budget allocations. Planning for the release rollout and the extraordinary deployment of team members was also part of the sub-project lead's responsibilities.

The customer portal of the large insurance group enables customers to manage contracts, update personal data, file damage reports and perform many other functions. The complexity lies primarily in the challenging system landscape of the group. Providing customers with a consistent and seamless interface requires extensive interface adjustments and coordination.

PROVI/PDB is a system in which all insurance products of a line of business are mapped. Due to the variety of products, the database is highly complex and frequently subject to structural changes that require adjustments to the web interface. In addition, denormalised data is extracted from the database as containers, serving downstream systems as a high-performance access point to the product base.

The Quality Gate was developed to test a newly developed intermediate layer connecting to a calculation core. It is used to send business test cases through the intermediate layer to the calculation core and evaluate the results. The Quality Gate includes test management, user management and management of tests to be executed. Test results can be viewed in real time via a web interface.

During the development, testing and acceptance of electronic control units, various documents are created. These documents contain circuit diagrams, test results and architecture information. They are stored and managed in the EEB document management system. This system offers various interfaces to adjacent systems and integrates ideally into the IT landscape of the automotive manufacturer.

A plug-in and evaluation component were developed for the MetaTrader platform. The plug-in delivered all traded data to a central server at the end of each trading day. The evaluation component processed and presented the data in an appealing format.

As part of the development of systems using hardware-in-the-loop and software-in-the-loop methods, documents were created and archived in DoRIS. DoRIS consists of a C# frontend and a Java backend. Version management, hierarchical document structure and version comparison are among the use cases of DoRIS.