The applications were implemented with Java EE and Java Spring Boot. JavaFX and React were used as front-end tools. The data was stored in an IBM DB2 database hosted on-premise. Jenkins was used for build and test automation. During the cloud migration, the applications were deployed in AKS (Azure Kubernetes Service).

• Modelling the software architecture
• Code Reviews
• Distribution of work within the team
• Interface definition
• Definition of Helm-Charts
• Definition of Git branch strategies
• Implementation of GitHub actions
• Testing the functionalities with Junit

Implementation of a data platform which is provided as microservices in Azure Kubernetes Service. The data platform makes it possible to request access to data resources, which can be authorised by the data owner. Data resources from Microsoft Azure ADLSGen2 or Databricks instances were supported. The microservices were implemented using Python and the FastAPI framework. Communication between the microservices was implemented using REST (synchronous) and Azure EventHub (asynchronous). A NoSQL CosmosDB instance was created as the database for each of the microservices. The microservices within the Kubernetes namespace were protected with Ingress/Egress Policies and the OAuth 2.0 standard. The resources were created automatically using Terraform. A CI/CD pipeline was created with GitHub Actions and ArgoCD to create the microservices as Docker images and deploy them on Kubernetes.

• Implementation of the microservices
• Modelling the software architecture
• Code Reviews
• Distribution of work within the team
• Interface definition
• Implementation of the authentication and authorisation layer
• Definition of Helm-Charts
• Definition of Git branch strategies
• Implementation of GitHub actions
• Testing the functionalities with Pytest

An API gateway was implemented using Apigee, where backend server endpoints can be seamlessly swapped without making changes to the client. Legacy SOAP endpoints and modern REST interfaces were available. The client sent the request to the API gateway according to the SOAP specification. The API gateway implemented a SOAP-to-REST transformation to forward the request to the REST endpoints. To ensure scalability, Apigee X was used, which runs on the Google Cloud. To be able to switch between the two endpoints, a frontend was implemented with NextJS and executed on Google Cloud App Engine. The frontend was secured with OAuth 2.0 and OpenID Connect.

• Design of the cloud architecture
• Implementation of the API gateway
• Customer communication
• Implementation of the front end
• SIntegration test

Development of a scalable and extensible validation platform for large volumes of financial transaction data. The application was deployed on the Google Cloud. Large files are saved to a Google Cloud storage bucket at regular intervals using batch operations. A cloud-managed Apache Airflow instance executes the validation logic and, after successful validation, stores the large amounts of data in BigQuery, where they can be analysed later. The validation logic was implemented with Python. By using the clean architecture, the application was easily testable and expandable for further validations.

• Development of the cloud architecture
• Implementation of the
• Validation platform
• Testing the platform
• Recording the requirements
• Stakeholder communication

Using a microservice architecture, a software architecture was developed and implemented that allows machine learning models to be executed with different programming languages after transformation into a standardised exchange format. The microservice architecture was implemented using Java Spring Boot.

• Microservice architecture
• Java Spring Boot
• Software architecture

Development of a cloud native application in which e-athletes play against each other with monetary stakes. The application was executed entirely on the Google Cloud. The front end was developed as a single-page application with React and provided via Firebase Hosting. Firestore was used as the database, which enables a real-time connection to the client using GRPC. Firebase Cloud Messaging was used to notify the frontend of specific events from the backend. The backend was implemented with TypeScript and the NodeJS framework and provided with Google Cloud Functions. PayPal and Stripes were supported as payment service providers.

• Development of the cloud architecture
• Implementation of the frontend (React)
• Implementation of the backend
• Stakeholder communication
• Requirements analysis
• Business development
• Communication with investors

An application was developed in which university hospitals can exchange information. The application was implemented with Java EE and an SQL PostgreSQL database was used as the database. An OpenID-Connect interface was implemented to simplify the authentication and authorisation of the application. Integration tests were carried out in a Bitbucket pipeline using Newman to send requests to the application.

• Improve the software architecture
• Implementation of an OpenID Connect
• Module
• Integration test with Postman and
• Newman