• Designed and implemented realtime anomaly detection system
• Integrated anomaly notifications within the client's data mesh architecture

In the fast-paced news industry, quick reactions to real-time developments are crucial. Our client, a web publisher, operates within a complex publication structure. Having transitioned from traditional print to online publication, they manage a network of independently branded websites, fed by content from a central editorial office.

Editors require real-time insights into topics’ performance, to push high-performing topics and improve those that are declining. To support editorial decisions, I conceptualized a system to alert editors and relevant staff about anomalies in traffic patterns across different categories. Additionally, technical use cases were implemented to notify about anomalies in traffic sources.

Anomaly detection relied on real-time data from an Apache Druid instance. We employed algorithms that analyzed past data and compared them with forecast estimates. When an anomaly was identified, the report was streamed into a Kafka topic. Downstream services managed push notifications to end-users.

The solution seamlessly integrated into the client’s data mesh architecture. I followed an MVP approach: Product features were iteratively developed in collaboration with end-users. I designed the system for production readiness, incorporating monitoring and alerting through Grafana.

• Applied Reinforcement Learning in Unity-Simulation
• Integrated trained AI-agent with hardware

For a robotic foosball table demo, human players faced off against a robotic contestant. Equipped with industrial-grade motors and actuators, the robot used a camera to monitor the field. My team and I enhanced the robot’s control software using reinforcement learning.

We precisely replicated the foosball table in a Unity simulation. The AI trained itself through continuous self-play in Unity, leveraging the SpinningUp reinforcement learning framework. Our self-developed hardware drivers bridged the gap between AI and real robot table. The AI’s dynamic gameplay even astonished us developers.

I maintained AI complexity with Test Driven Development, using test suites as feature documentation. This approach facilitated smooth onboarding for temporary team members on multiple occasions.

• Developed and deployed Machine Learning Pipelines
• Trained, quantized, and accelerated Deep Learning Computer Vision models

A security infrastructure provider created an IoT platform for security cameras, allowing AI models for scene recognition to function as apps. I worked in an interdisciplinary team, researching and developing demo apps for common use cases.

Cloud-based model training and deployment (Python, TensorFlow, Terraform, Docker) laid the foundation. I contributed to the data-driven architecture, crafting scalable machine learning pipelines for inference and re-training feedback loops.

We honed models with quantization for mobile devices’ hardware acceleration (e.g. Qualcomm Hexagon). Quantized (MobileNet) and unquantized models, plus server-side models (e.g. ResNet), underwent performance comparisons.

Deployment occurred within Android-based cameras, acting as the app shell.

• Developed machine learning pipelines for behavior classification
• Employed clustering techniques on multivariate timeseries data

Analyzing anonymized personal movement data from supermarket cameras posed two challenges: data cleaning and behavior classification.

We calculated person movement similarity using dynamic time warping (DTW). For behavior clusters, we applied k-medoids and hierarchical agglomerative clustering on multivariate data. Using cluster centroids as classifier archetypes, our AI prototype accurately classified customer entering and exiting, validated against manual counts.

Our deliverable was a containerizable software suite assessing algorithmic strategy performance.

• Analyzed and engineered requirements for assistant AI for user input suggestions
• Developed machine learning model for multi-label prediction

To streamline industrial deliveries, users of the customer system grappled with a complex web-interface. Creating a packaging strategy required numerous repetitive manual steps due to years of feature accumulation that increased software power but sacrificed usability.

My team scrutinized requirements, delivering an AI prototype. We collaborated extensively with various departments, fostering enhanced communication within the customer organization.

Accessing sensitive production data for AI training required a secure pattern involving remote desktop connections and VPN. Our AI employed a random forest classifier with multi-label output. This algorithm learned packaging strategies from past deliveries, suggesting them to users.

The successful AI-POC spurred a production-ready order.

• Streamlined and expanded service architecture
• Led frontend development and maintained geodata pipeline

My client’s team of data journalists aims to deliver engaging data experiences to readers, especially in mobile browsers. Their goals include providing real-time data on German regional elections and presenting an interactive geopolitical map of Ukraine.

In the dynamic news field, speed to production is paramount. To meet this demand, I merged two artifacts – a create-react-app frontend and a Node.js API—into a single NextJS application. This unified solution serves both React client code and essential data APIs, integrating seamlessly with the higher-level CMS of affiliated news sites.

I introduced a CMS-like feature, enabling editors to publish and embed new data visualizations without developer intervention. This approach reduces costs and organizational complexity.

Some data structures extended from the backend into the frontend, so I created decoupling points to enhance maintainability and extensibility. The streamlined architecture empowers junior developers to add new features with reduced complexity.

• Architected app's demo mode for millions of users
• Led team and harmonized processes with nearshore colleagues (Romania, Germany)

Enhancing a Flutter app with a demo mode to showcase its benefits to potential users was our task. Requirements included ensuring features behaved “as if connected to a real vehicle”. However, fragmented feature development led to a lack of a complete development scope. We quickly overcame this by analyzing production UI and existing code.

With a newly-formed team split between Romania and our parent company, communication was vital. My nearshoring expertise facilitated seamless interaction. Building trust through clear architecture documentation bolstered our customer relationships.

As an architect, I restructured the app, allowing parallel development of demo features by individual developers. This loose coupling promoted scalability. Our successful demo mode launch led to us handling more core features. With team growth, I trained new developers, maintained high code quality, and architected new functionalities.

• Incremental migration of extensive JavaScript frontend to React with TypeScript
• Refactored microservice backend architecture and documentation

Working collaboratively, we conducted an incremental migration of an extensive JavaScript frontend to React with TypeScript, alongside parallel development of new features. The existing code lacked tests and contained undocumented but vital business logic. We embraced Test Driven Development for our React codebase, enabling stable releases.

We assisted the customer in refining the front end’s logic, now backed by testing. This refinement extended to the legacy PHP backend. Through clear architecture and transparent inter-team communication, we relocated misplaced logic to intended services.

Our fully remote team included members from Germany, Hungary, and Egypt. Meanwhile, the customer organization transitioned to SAFe. As a Scrum Master, I guided the team through new processes, helping shape them and emphasizing the significance of CI/CD.

• Developed intuitive React-Redux frontend with Material UI
• Designed API and built JavaEE backend

Operating within the customer’s SAFe framework, our multi-provider team embarked on standardizing a quality management process (9S), featuring a complex status model. To deliver an intuitive user experience, we harnessed Material-UI as the component library of choice.

Our outcome? A functionally-driven React frontend supported by a JavaEE backend. This backend, meticulously designed, retained full test coverage, facilitating agile responses to evolving requirements and streamlined logic patch releases. The beauty? Frontend remained free from business logic, while backend thrived. Our efforts helped navigate change and deliver seamless solutions.