I’m excited to join Wandelbots as a Senior Software Engineer! We’re building no-code solutions that make industrial robotics accessible to everyone.

Traditional robot programming is complex, especially when environments change frequently, making it extremely hard to account for every variation in code. Wandelbots is changing this by letting robots learn from human demonstrations and adapt to new situations through imitation learning.

I’m working across several areas. On the platform side, I’m building infrastructure that lets customers embed interactive 3D robot visualizations in their own applications using Three.js and React. This includes real-time robot simulation and path planning visualization. I’m also contributing to AI systems where robots learn from human demonstrations to adapt to changing environments that would otherwise be very difficult to program explicitly. Additionally, I’m developing specialized industrial solutions like robot welding applications with path planning and weld parameter optimization.

The tech stack spans TypeScript, React, Three.js, Python, WebGL, and ROS. It’s a great mix of full-stack development, 3D graphics, robotics control systems, and cutting-edge AI/ML work. Looking forward to helping manufacturers adopt robotics automation more easily!

Learn more about Wandelbots

Google Play recognized SQIN as one of the Best Apps of 2020 in the #PersonalGrowth category! 🥇

Out of millions of apps on Google Play, SQIN was selected for Google’s prestigious annual awards. It’s a beauty and skincare app that helps users make informed decisions about cosmetic products through ingredient analysis, personalized recommendations, and community reviews.

As a lead developer, I worked on performance optimization, technical architecture improvements, and implementing beauty and skincare analysis features. This included mobile app development with modern Android best practices and integration with computer vision and ML systems for product recognition and analysis.

The award was great validation of our focus on user experience and technical excellence in the personal care space.

View Google Play Best of 2020 Collection

Built a custom face analysis system for SQIN using TensorFlow Lite and Unity. The system does accurate facial feature recognition across devices without requiring ARKit or ARCore.

I developed a Unity plugin that integrates TensorFlow Lite for real-time 3D face mesh extraction. It’s based on Google’s MediaPipe Face Mesh technology but optimized for mobile performance. The plugin works consistently across iOS, Android, and even the Unity Editor, with no dependency on platform-specific AR frameworks. We’re getting 30+ FPS on mid-range devices with 468 3D facial landmark points.

The implementation involved building a custom C++ to C# bridge for TensorFlow Lite integration and careful memory management to stay within mobile constraints. The face scanner analyzes facial features to provide personalized skincare and beauty product recommendations tailored to face shape, skin tone, and other features.

The main challenge was achieving reliable face mesh extraction without platform-specific AR frameworks. This made the feature accessible to a much broader range of devices while maintaining high performance and accuracy.

Built with Unity, C#, C++, and TensorFlow Lite.

The situation report from the RKI contains a figure which shows the development of the pandemic in Germany over the last 7 days. I wanted to know how this progresses over time and whether the outbreak clusters remain regional.

I used Pandas and Folium to recreate the figure and created this animation. See the code on Github to reproduce the result with current data.

I used Pandas to preprocess the raw data from the RKI.

def new_cases_by_date(rki_raw, rki_flag_column='Neuer Fall', rki_count_columns='AnzahlFall'):
    condition = rki_raw[rki_flag_column].isin((0, 1))
    rki_series = rki_raw[condition].groupby(['IdLandkreis'])[rki_count_columns].sum().to_frame(name = rki_count_columns).reset_index()
    
    rki_series = rki_series[['IdLandkreis', 'AnzahlFall']]

    # join geodata
    rki_series['IdLandkreis'] = rki_series['IdLandkreis'].astype(str).str.zfill(5)
    rki_series = rki_series.set_index('IdLandkreis')
    rki_series = rki_series.join(rki_geo)

    return rki_series

start_date = pd.to_datetime('2020-03-01')
end_date = rki_raw.index.max().tz_convert(None)

frames = []

for j in pd.date_range(start_date, end_date - pd.to_timedelta(6,'d')):
    startrange = j.strftime('%Y-%m-%d')
    endrange = (j + pd.to_timedelta(6,'d')).strftime('%Y-%m-%d')
    rki_cases = new_cases_by_date(rki_raw[startrange:endrange], rki_flag_column='NeuerFall', rki_count_columns='AnzahlFall')
    rki_cases['date'] = (j + pd.to_timedelta(6,'d'))
    rki_cases['RS'] = rki_cases.index
    rki_cases['cases_per_100k'] = rki_cases['AnzahlFall'] / rki_cases['EWZ'] * 100000

    rki_cases = rki_cases.set_index('date')
    frames.append(rki_cases)

result = pd.concat(frames)

The map is generated with the choropleth function from Folium. Selenium is used to store the maps as png sequence.

bins = [0, 5, 25, 50, 100, 500]
map_osm = folium.Map(attr="Robert Koch-Institut (RKI), dl-de/by-2-0", location=[51.3, 10.5], tiles='cartodbpositron', zoom_start=7)

#result.apply(lambda row:folium.GeoJson(row[1], fill_color=colorscale(row[0])).add_to(map_osm), axis=1)
folium.Choropleth(
    geo_data=rki_geo_raw,
    data=result['03-10-2020':'03-10-2020'],
    columns=['RS', 'cases_per_100k'],
    key_on='feature.properties.RS',
    fill_color='YlOrRd',
    fill_opacity=0.6,
    line_opacity=0.0,
    nan_fill_color='#f5f5f3',
    legend_name='cases per 100k',
    bins=[float(x) for x in bins],
    smooth_factor = 0.1
).add_to(map_osm)

The final animation is created with FFMPEG and this Gist

Github

We developed a product recognition system using machine learning that identifies cosmetic products without requiring barcodes. Many beauty products either don’t have visible barcodes or they’re hidden inside packaging, so this was a real game-changer for the user experience.

The system uses a custom-trained convolutional neural network that can recognize products in real-time on mobile devices. It works even with partial product views and various lighting conditions, handling thousands of SKUs with high accuracy. The architecture is optimized for on-device inference, so it’s fast and works offline once the model is downloaded.

We integrated it with a product database and inventory system, and added a gamification layer where users earn stars for scanning products. They can exchange these stars for vouchers and products, which significantly improved engagement.

The technical implementation involved mobile-first architecture, integration with backend systems for the product catalog, and careful optimization to make the inference run smoothly on mid-range devices. We built it with TensorFlow/PyTorch for the ML components, standard mobile development frameworks for Android/iOS, and REST APIs for the backend communication.

We showcased our new app BeQu at Glow 2019. For two days users could try out exclusive content and win products from our partner brands!

In our app, we link the right users with the products that interest them in the form of mobile games, user surveys and state-of-the-art augmented reality. BeQu turns simple shopping into an emotional, shareable experience that takes the pulse of the hard-to-reach millennials up to the Alpha generation.

Explored Make-Up Style Transfer with BeautyGAN.

The network is trained with make-up and non-make-up pictures. It’s possible to apply different make-up styles (eg. from Influencers from Instagram) to your image. See the picture for examples.

An ASMR game prototype this time together with @pavethem. The goal of the game is to draw latte art and satisfy your customers. We used fluid dynamics (base from stable fluids) on the GPU to simulate the foam.

Different kind of training for CR7 to use him as a virtual avatar with Pix2Pix (using the code of datitran).

I generated the dataset from this video. The Network is trained with OpenCV landmark images from a source video. The same landmark detection is applied to the webcam output.

Experimenting with ML-driven design analysis using visual importance networks trained on eye-tracking data to predict where users focus attention in UI designs.

Visual importance is a machine learning approach trained on real eye-tracking heatmaps from UI studies. The network predicts which areas of a design naturally draw user attention - red areas show high interest, blue shows low interest.

I applied the model to Instagram’s Oscar feed and analyzed designs from our Quiz Friends app to validate UI flow. The model effectively highlights high-contrast areas and visual hierarchy, but it primarily learned to detect contrast rather than semantic importance or reading flow patterns. It’s useful for quick design iteration and identifying potential attention conflicts, but needs to be combined with user flow analysis, A/B testing, and traditional usability testing for comprehensive UX analysis.

I integrated it with our design pipeline using Python and TensorFlow/PyTorch to generate automated heatmaps for rapid design feedback. It’s a nice example of how ML can augment traditional UX research methods during the design iteration phase, even if it can’t replace them.