Making systems work together.

The interesting part is what happens between systems: translating data, coordinating asynchronous work and making failures understandable. My focus is on maintainable interfaces and clear operational visibility.

I’m interested in turning complex datasets into practical workflows: importing, validating, transforming and exporting information, with interfaces that give users control over the process.

From a database model to the screen a user interacts with, I enjoy working across the stack. Clear boundaries, straightforward interfaces and a strong foundation make a product easier to evolve.

I develop backend systems with Python, Django, and FastAPI, turning complex business requirements into maintainable applications. My work includes designing REST APIs, modelling data in PostgreSQL, integrating external platforms, and automating workflows with background tasks.

I focus on clear architecture, secure authentication, efficient database queries, and dependable error handling. From ERP and e-commerce integrations to internal business tools, I build services that are easy to operate, troubleshoot, and extend.

My work spans internal applications, platform integrations and infrastructure. I connect business requirements with technical implementation, with particular attention to the workflows between commerce, product data, ERP and logistics.

I enjoy working close to the people who use the software: understanding a process, identifying where it breaks down and building tools that make the next step clearer.

My approach starts with the actual workflow and the information it needs. From there, I define a data model and service boundaries, build the application and consider how it will be operated.

I value maintainable code, explicit rules and useful error handling. A successful system needs to remain understandable as requirements change.

Building services that expose clear interfaces and model real business processes. My projects include data imports, platform connectors and background workflows. I work with FastAPI for API-oriented services and Django where its application structure and ORM fit the problem.

Connecting backend functionality to usable screens. I focus on clear forms, understandable status information and controls that give users visibility into imports, configuration and everyday tasks.

Relational modelling, SQL queries and structured data transformations. For tasks that should run outside the request cycle, I work with background workers and queues. I consider validation, repeatable processing and failure recovery alongside the happy path.

Container-based application deployment and the supporting infrastructure. My interests include CI/CD, object storage, reverse proxies and the operational details that keep an application accessible and maintainable.

The Challenge

Modern e-commerce and logistics operations depend on multiple interconnected systems, each with its own APIs, data structures, communication protocols, and business processes.

Keeping orders, inventory levels, shipment information, and fulfilment statuses synchronized across these systems introduces significant technical challenges. Different platforms operate asynchronously, enforce different API limitations, and use different document formats and workflows.

Failures in communication, delayed responses, inconsistent data, or unexpected system behavior can quickly affect business operations.

The challenge was to build a reliable, extensible integration platform that could orchestrate these processes while providing transparency, fault tolerance, and control over complex workflows.

The Approach

I designed and developed a modular integration platform built around a FastAPI backend, PostgreSQL database, React frontend, and Celery background workers.

The architecture separates platform-specific integrations from the core application, allowing individual connectors to implement their own business logic, API communication, document processing, and synchronization workflows.

Background workers handle asynchronous operations such as order synchronization, inventory updates, XML document processing, and logistics status updates without blocking the application.

A centralized web interface provides visibility into integration processes, configuration management, execution statuses, and operational workflows.

The architecture emphasizes separation of concerns, maintainability, extensibility, and reliable background processing.

Areas of Work

ERP & Logistics Integration

Integration between Xentral ERP and Swiss Post fulfilment services, enabling automated communication between internal business processes and external logistics infrastructure.

This includes order transmission, inventory synchronization, warehouse operations, shipment tracking, and logistics status processing.

Asynchronous Processing & Workflow Orchestration

Development of background processing workflows using Celery and Redis to handle long-running operations, scheduled synchronization tasks, and external system communication.

A particular focus is placed on task isolation, retry strategies, error handling, and the reliable execution of independent integration workflows.

Configurable Document Processing

Implementation of configurable XML-based integration workflows for exchanging structured business documents with external systems.

Configuration-driven mappings and transformation rules help reduce duplicated code and make it easier to accommodate differences between integration partners.

Modular Connector Architecture

Development of a connector architecture in which platform-specific functionality is organized into independent modules.

This design makes it possible to extend the platform with additional systems, document types, and integration processes without unnecessarily coupling them to existing implementations.

Monitoring & Operational Transparency

Providing visibility into asynchronous operations, synchronization progress, processing errors, and integration statuses.

The objective is to make complex background processes easier to understand, troubleshoot, and operate.

Technical Stack

• Backend: Python, FastAPI, SQLAlchemy
• Frontend: React, TypeScript
• Database: PostgreSQL
• Task Processing: Celery, Redis
• Integration: REST APIs, XML, SFTP, webhooks
• Infrastructure: Docker, Linux, GitLab CI/CD
• Architecture: Modular services, asynchronous processing, configuration-driven workflows

Engineering Focus

My primary focus is on designing systems that remain understandable and maintainable as their complexity grows.

Rather than implementing integrations as isolated scripts, I approach them as components of a larger platform with clearly defined responsibilities, reusable infrastructure, and consistent operational behavior.

This project brings together several areas of software engineering that I particularly enjoy: backend architecture, distributed systems, API integration, workflow automation, and infrastructure engineering.

The long-term goal is to provide a flexible integration foundation that can accommodate additional marketplaces, logistics providers, and business systems while keeping the core architecture stable and maintainable.

The challenge Product information and images need to be imported, related to the right articles and made available to other applications.

The approach A FastAPI backend with asynchronous PostgreSQL access, product and asset models, and Xentral product imports. Progress reporting gives visibility into longer imports. Product images are made available through object storage and a CDN.

Focus Clear product identifiers, explicit asset ordering and a structure that can evolve as product data requirements grow.

The challenge Repeated product creation and CSV transformations can become difficult to maintain when rules are scattered across spreadsheets and scripts.

The direction A Django application that combines datasets with reusable rulesets and generates configurable CSV outputs. The design includes flexible join keys, schema mapping, split outputs and a visual interface with an advanced expression mode.

Planned extension Brand-specific product templates with overrides, including related products such as a toner set and its individual colours. This is an ongoing design and development effort.

The concept A dedicated application for presenting unique artworks and connecting artists with buyers.

The stack Django REST and React, with managed PostgreSQL and S3-compatible object storage. Deployment work uses Ubuntu and Podman on an EU-based cloud platform.

Architecture focus Separate application, database and asset storage responsibilities, with private networking where supported. The project is ongoing; the description reflects its technical direction rather than a completed marketplace launch.

Project Overview

Designed and developed a modern personal portfolio platform that combines a responsive public-facing website with a custom content management system (CMS).

Unlike traditional static portfolio websites, the platform enables content, projects, and visual elements to be managed through an intuitive administration interface without modifying source code.

Key Features

• Dynamic Content Management: Create, edit, duplicate, reorder, and delete portfolio entries through a dedicated administration interface.
• Visual Editor: Customize portfolio content, descriptions, layouts, and presentation with immediate draft previews.
• Theme Customization: Manage colors and visual styling to personalize the website's appearance.
• Secure Administration: Authentication-protected access to website management functionality.
• Responsive Design: Modern user interface optimized for desktop, tablet, and mobile devices.
• Draft & Publishing Workflow: Preview changes before publishing them to the live website.
• Cloud Integration: Integration with object storage for managing and delivering media assets.
• Automated Deployment: CI/CD workflows for consistent deployment and application updates.

Technical Architecture

The application follows a full-stack architecture with clearly separated frontend, backend, and infrastructure responsibilities.

The frontend uses React and Mantine to deliver a responsive, component-based interface. The backend provides API endpoints for managing content, authentication, and application configuration.

The application is deployed on cloud infrastructure with automated deployment workflows, centralized asset storage, and secure HTTPS access.

Engineering Focus

This project demonstrates practical experience in full-stack engineering, frontend architecture, backend API development, user experience design, cloud deployment, and the development of reusable content management components.

The architecture is designed for maintainability, extensibility, and future enhancements.

Context An ERP must be able to reach a public webhook, while operational APIs should have more restricted access. Long-running integration work also needs to be separated from incoming HTTP requests.

Design direction Keep event intake small, hand processing to background workers and organise platform logic into dedicated modules. Decoupling webhook intake from the main application is a planned evolution.

Tradeoffs Asynchronous processing improves separation but introduces delivery and ordering concerns. Idempotency, retry behaviour and traceable statuses are design priorities.

Context Product templates should support brand defaults, per-product overrides and the creation of related articles. Changes also need to remain traceable.

Design direction A custom Django-based PIM with PostgreSQL, reusable template rules and an audit trail. Database triggers are being considered to capture article changes consistently, alongside application-level context.

Tradeoffs Database-level auditing can cover multiple write paths, but actor identity and business intent must be passed explicitly. Template inheritance needs clear precedence rules and validation. This case study describes an architecture under consideration.

Context Product images and artwork files have different access and storage needs from transactional application data.

Approach Store structured records and asset references in PostgreSQL, with files in S3-compatible object storage. Serve assets through a dedicated delivery path, while application services manage their metadata and relationships.

Tradeoffs The database and object store do not share a transaction. Upload, replacement and cleanup workflows need to account for partial failure and unused files.

The available hardware includes three IBM x3550 M5 servers and IBM Storwize storage. My planning covers how to use these resources for virtual machines and a Kubernetes learning environment.

Proxmox HA, Ceph and k3s are targets for the lab, rather than claims of a finished production cluster. I am working through storage design, failure domains and the practical cost of keeping multiple nodes running.

My networking setup centres on a MikroTik RB5009 router and MikroTik switching. I am interested in clear network boundaries, manageable cabling and understanding how traffic moves between services.

The physical layout matters too: compact equipment, a 10-inch rack direction and accessible patching help make the lab easier to maintain.

Large servers are useful for experimenting with memory-heavy workloads and storage, but power and noise influence what is practical to run continuously.

I am evaluating compact compute options alongside the existing equipment. The goal is a lab that supports application hosting and infrastructure experiments without making every experiment depend on a fully powered cluster.