• Designed and implemented a Scala/Spark Streaming data product on Azure to ingest real?time vehicle telemetry from Kafka topics and compute RDE KPIs at scale.
• Persisted results in Delta Lake on Azure and integrated with Qlik dashboards
• LLM integration via LangGraph/MCP interfaces for regulatory stakeholders to analyse emissions behaviour across fleets.
• Established monitoring and alerting via Splunk

• Built PySpark/Spark pipelines on Azure Databricks leveraging Apache Sedona to anonymise thousands of GPS coordinates per second from connected vehicles.
• Persisted anonymised datasets to Delta Lake and MongoDB
• Integration with Open Street Maps (GIS) using LangGraph.
• Defined metrics, monitoring and alerting in Splunk to ensure data protection and operational correctness.

• Implemented PySpark and tslearn?based UDFs to perform Dynamic Time Warping across three multivariate time?series streams, processing 5?8 billion records per run.
• Used PyTorch models to filter and pre?select relevant segments, reducing downstream computation cost and improving quality of merged time?series datasets.
• Persisted merged and enriched datasets into CosmoDB to support subsequent ML modelling and analytics.

• Built Scala/Python Spark pipelines on Azure Databricks and Airflow to ingest, cleanse and stage vehicle and telemetry data from Kafka streams into Delta Lake.
• Standardised ingestion patterns, including schema management, partitioning strategies and error handling, enabling downstream teams to onboard data faster.
• Established metrics and operational dashboards in Splunk, improving incident response and data quality visibility.

• Implemented automated schema publishing via GitLab CI/CD to ensure that changes to data contracts were tracked and governed.
• Integrated data products with Collibra as a central data catalogue, improving discoverability, lineage visibility and ownership clarity.

• Developed a Scala/Databricks Spark Streaming?based product to monitor electric vehicle charging sessions in real time using Kafka as the ingestion backbone.
• Persisted vehicle charging state in CosmosDB for low?latency updates and stateful tracking, and exposed KPIs via Splunk and a Qlik?based frontend.
• Enabled operational teams to detect anomalies and issues in charging infrastructure quickly.

• Built a PySpark?based on Azure Databricks framework to allow data analysts and data scientists to plug in analytics code and run it safely on production data.
• Enforced tests via GitLab hooks, and standardised results persistence to Iceberg.
• Reduced time?to?production for new analytics from weeks to days by encapsulating patterns for job orchestration, validation and logging.

• Designed Scala/Java ingestion pipelines to consume Oracle CDC data via Oracle GoldenGate connectors into Kafka, providing a near real?time mirror of transactional systems.
• Implemented enrichment logic using Kafka Streams and Spark Streaming, transforming CDC events into analytics?ready structures.
• Landed data into Amazon S3 for query via Athena and integrated Prometheus/Grafana dashboards for performance and reliability monitoring.

• Led design of an AWS/Java application for forecasting supply and demand across multiple locations using data streamed from on?prem Kafka into Kinesis via Direct Connect and custom Kafka?to?Kinesis connectors on Fargate.
• Utilised Kinesis Analytics for real?time grouping and aggregation, storing enriched results in Aurora (PostgreSQL flavour) and using DynamoDB as a cache layer.
• Delivered dashboards through QuickSight and enabled Power BI access via JDBC; orchestrated ETL workloads with EMR/Spark; configured CloudWatch/SNS for logs and alerts.

• Conducted use?case analysis and designed an AWS?based streaming platform centred on Kinesis and Lambda for event ingestion and processing.
• Designed persistence strategy using S3, DynamoDB and Aurora to support batch, key?value and relational access patterns.
• Integrated SageMaker as a machine learning workbench

• Implemented an AWS/Java microservices?based solution providing low?latency location search for connected cars.
• Used Terraform for infrastructure as code, Direct Connect and VPCs for secure hybrid connectivity and EMR/Spark for ETL processing.
• Utilised S3 and REST APIs for third?party integrations, Aurora and DynamoDB for persistence, API Gateway for access control and monitoring, and CloudWatch/SNS for observability.

• Designed an AWS/Java solution that ingested real?time car positions as Kinesis streams to orchestrate autonomous movement between factory stations.
• Implemented Lambda functions and backend services using Aurora and DynamoDB to compute and persist the next positions and states of vehicles.
• Used EMR/Spark and Glue for ETL on historical data and CloudWatch/SNS for monitoring operational behaviour.

• Developed an event?driven ML platform where KStreams applications on Kubernetes/OpenShift consumed Kafka events and applied ML models in real time.
• Integrated KubeFlow for model deployment and lifecycle management, and DVC for model version control and reproducibility.
• Used Neo4j as a graph database for relational search and exposed a GraphQL microservices layer on OpenShift for flexible querying.

• Led design of a Kubernetes?based ?Ingestion as a Service? product allowing teams to deploy GDPR?aware ingestion pipelines with minimal effort.
• Implemented Scala?based microservices (Akka HTTP) as event proxies, Kafka on Kubernetes via Strimzi, and Avro schema validators and transformers for PII handling.
• Supported sinks for Hive, S3, Cassandra and Kafka, and integrated Prometheus/Grafana monitoring.

• Architected a Scala/Spark solution that consumed click events from Kafka and generated user profiles in near real time.
• Combined Spark Streaming for online updates with Spark Batch for computing priors, storing priors in MongoDB and profiles in Cassandra.
• Built Akka HTTP microservices to serve user profiles with sub?50 ms latency at up to 5000 requests/second; instrumented dashboards via Kibana and Prometheus/Grafana.

• Developed a Scala/Kafka?based system that applied ML models (Random Forests exported from H2O .ai and stored as JSON in MongoDB) to incoming listing change events.
• Used KStreams to enrich listings with ML?derived price categories and built Akka HTTP microservices to serve price transparency and average price information.
• Integrated Kibana dashboards and Prometheus/Grafana

• Designed and implemented a Java/Scala/Spark framework extending existing data capabilities with GDPR functionality.
• Introduced Bloom filters for efficient historical data search and leveraged Cassandra tombstones to process ?right to be forgotten? requests.
• Built Spring Boot microservices for the serving layer and integrated Prometheus/Grafana for operational visibility.

• Architected a Java/ElasticSearch?based recommendation engine that combined user profiles from Cassandra with item attributes in ElasticSearch.
• Served TensorFlow models via TensorFlow Serving and stored profile priors in MongoDB; designed ElasticSearch schemas and queries to achieve <50 ms latency for ~1600 requests/ second.
• Implemented decay?based ranking and preference modelling, contributing to a significant uplift in conversion; ensured observability through Kibana, Gatling load tests and Prometheus/ Grafana.

• Designed a Java/ElasticSearch solution for item?based recommendations using listing attributes and similarity for item?to?item suggestions.
• Incorporated ML?derived weights from data scientists into ElasticSearch queries and scaled serving to ~1600 requests/second at 50 ms latency.
• Implemented Learn?to?Rank?based automatic weight deduction using historical truth data

• Implemented a Scala/Cassandra/Kafka?based service that ingested user activity events via Kafka Streams and persisted them in Cassandra and PostgreSQL.
• Exposed Spring Boot microservices for low?latency reads by downstream applications; added comprehensive metrics via Prometheus and Grafana.

• Built Java/Spring services that applied trained H2O .ai models (served as POJOs) on incoming listing data to classify listings as fraudulent or non?fraudulent.
• Integrated Kafka and logging frameworks to track decisions, and used Kibana dashboards to monitor model precision and recall over time.
• Collaborated with data scientists to iterate on model performance and deployment patterns.

• Designed a Java/Spring backend using Bayesian probabilistic methods to score and classify incoming listings based on multiple signals.
• Implemented JavaScript?based user fingerprinting, Kafka and RabbitMQ as ingestion mechanisms, and MySQL/MongoDB for persistence.
• Tracked model metrics with Kibana and Prometheus/Grafana, enabling iterative improvement.

• Built a Java/Neo4j solution performing social ring analysis on login and click data to detect groups of compromised accounts.
• Modelled relationships and behaviours in Neo4j and implemented graph queries that significantly reduced platform ATO incidents.

• Developed a Java/Spring microservices?based platform for persisting, fetching and displaying dealer ratings, supported by MySQL and MongoDB via Hibernate.
• Implemented near real?time fraud detection for reviews using Kafka/KStreams and Spark Streaming and batch ETL via Spark Core.
• Used Logstash and ElasticSearch for search and visualisation, with Gattling for load testing and Prometheus/Grafana for metrics.

• Worked on a Java/Spring multi?tier ?Mobile Gateway? product synchronising non?smartphones with email (push email), calendar and contacts.
• Used Hibernate and PostgreSQL for persistence, JSP/JSF/JavaScript/CSS for front?end components and implemented support for multiple protocols (SyncML, IMAP, XMPP, ActiveSync).
• Contributed to open?source efforts (e.g., as a committer to the Open Data Sync project), improving interoperability and standards support.

Master Thesis: Enterprise Semantic Search

• Developed an enterprise semantic search solution supporting multiple file formats and knowledge extraction.
• Implemented named entity detection and text transformation pipelines using Lucene, OpenNLP and UIMA to build searchable indexes.

• Implemented enhancements for a Matrix PLM system using JSP, JSF, JavaScript and CSS to improve usability and workflow support.