Selected projects

Software, data and automation put into practice.

Each case separates the problem, the engineering decisions behind it and what you can inspect directly in the public repository.

Astro, WebGL and DevSecOpsVerified code

IoCode-WEB: trilingual industrial platform

ES/EN/DE static site with a progressive 3D hero, technical SEO, accessible testing and hardened container delivery.

Challenge:: Publish a multilingual industrial proposition without trading away performance, accessibility, release traceability or HTTP security.
Solution:: Static Astro architecture with TypeScript, progressively loaded Three.js, hash-based CSP, Nginx, digest-pinned OCI images and Playwright/Axe gates.
Technical role:: Frontend architecture, i18n, WebGL runtime, Docker/Nginx hardening, CI/CD automation and QA contracts.
Value:: The build generates 66 pages from one typed codebase for three languages, with reproducible build, security and accessibility controls.
What you can inspect:: Source, Compose, Nginx, workflows, 17 E2E specifications and nine unit suites are publicly inspectable on GitHub.

In practice: Build, security and accessibility gates executed and verified on every candidate release, ready to govern production deployment.

Open technical case

GitHub

Kotlin and mobile architectureVerified code

TechWizards: layered Android application

Android app with use cases, authentication, encrypted credentials, persistence and explicit layer boundaries.

Challenge:: Prevent authentication, UI, preferences, match history and game rules from becoming coupled as the mobile app grows.
Solution:: Kotlin code organized into core, use-case, data and UI layers with Firebase, Jetpack Compose and encrypted credential storage.
Technical role:: Architecture design, Kotlin implementation, identity and persistence integration, plus in-code documentation.
Value:: The public structure makes responsibilities traceable, dependencies replaceable and workflows testable without centralizing logic in one activity.
What you can inspect:: The public tree includes use cases, ServiceLocator, SessionManager, EncryptedCredentialsStore, SQL and instrumented tests.

In practice: Layered Android architecture with offline persistence, identity management and clear separation of responsibilities for a maintainable, extensible codebase.

Open technical case

GitHub

ERP and integration architectureVerified code

HotelSOL: .NET, Odoo and data integration

Integration environment connecting a .NET API, an Odoo module, SQL Server and PostgreSQL through Docker Compose.

Challenge:: Coordinate bookings, guests, charges and synchronization between a management application and an ERP with separate data stores.
Solution:: Reproducible stack with SQL Server, PostgreSQL, Odoo 19, a Python module, C# API, healthcheck and initialization scripts.
Technical role:: Data modelling, service integration, container configuration, XML export and Odoo module testing.
Value:: The public Compose file coordinates five services and reproducibly separates initialization, persistence and runtime.
What you can inspect:: Repository with C#, Python, T-SQL, an Odoo module, tests, XML, Dockerfiles and public Compose configuration.

In practice: Multi-service ERP architecture coordinating a .NET API, an Odoo module and SQL Server/PostgreSQL data stores, with Docker Compose configured for reproducible deployment.

Open technical case

GitHub

Java and object-oriented programmingTechnical demonstration

WoodShops: Java commercial domain model

Domain model for stores, warehouses, products, suppliers, customers and sales using specialized Java classes.

Challenge:: Represent timber retail rules and entities without concentrating inventory, customers, suppliers and sales in one class.
Solution:: Object-oriented domain with article and customer hierarchies, sales details and separate manager classes.
Technical role:: Entity, relationship, inheritance and business-operation modelling in Java.
Value:: The public tree contains more than fifteen domain classes that make system responsibilities explicit.
What you can inspect:: Visible Java code for Store, Warehouse, Article, Product, Supplier, Customer, Sale and SaleDetail entities.

In practice: Object-oriented domain modelling in Java, with inheritance and specialized classes separating inventory, customers, suppliers and sales.

Open technical case

GitHub

Fleet and contract modellingTechnical demonstration

Vehicle rental: Java OOP

Application modelling an agency, fleet, customers, rental contracts and several vehicle types.

Challenge:: Manage cars, motorcycles and trucks with shared rules without duplicating structure or contract logic.
Solution:: Java vehicle hierarchy plus agency, fleet, customer and rental-contract classes.
Technical role:: Object-oriented design, inheritance, encapsulation and fleet/contract operations.
Value:: The public code separates vehicles, customers, fleet and contracting into nine identifiable classes.
What you can inspect:: Public Java sources for Agency, Fleet, Vehicle, Car, Motorcycle, Truck, Customer and RentalContract.

In practice: Fleet and contract modelling in Java through inheritance and encapsulation, with separate classes for agency, customer, vehicle and contract.

Open technical case

GitHub

Data-driven desktop applicationVerified code

The Javengers: JavaFX, JDBC and DAO

Java project for members, federations, trips and registrations with a JavaFX UI and DAO persistence.

Challenge:: Keep UI, domain rules and SQL persistence separate in an association-management desktop application.
Solution:: JavaFX, model, DAO/DAOImpl, JDBC, domain-exception, SQL and JUnit test layers.
Technical role:: Modelling, persistence, controllers, scene management, validation and domain exceptions.
Value:: The repository makes operations traceable from controllers and scenes to DAO interfaces and SQL implementations.
What you can inspect:: Public tree with DAOFactory, five DAO/DAOImpl pairs, domain exceptions, SQL scripts and JavaFX sources.

In practice: Team-built JavaFX architecture with JDBC/DAO persistence, separating UI, controllers, domain logic and data access into independent layers.

Open technical case

GitHub

Relational modelling and forward engineeringVerified code

Coworking database with MySQL

Schema for managing coworking entities and relationships through relational design.

Challenge:: Translate coworking-management requirements into consistent tables, keys and relationships before application implementation.
Solution:: Entity-relationship diagram, physical model and scripts generated through forward engineering.
Technical role:: Normalization, ER design, key definition and physical-schema generation.
Value:: The repository preserves models, relationships, foreign keys and SQL for tracing logical design into a physical schema.
What you can inspect:: Public description and MySQL Workbench artefacts with SQL, tables, foreign keys and relational models.

In practice: Relational modelling and normalization with MySQL Workbench, from the entity-relationship diagram to the physical schema generated through forward engineering.

Open technical case

GitHub

Python, scenes and animationTechnical demonstration

Break Boxes: modular Python game

Modular 2D game structured into separate components for player state, scenes, animations and colour management.

Challenge:: Avoid mixing the game loop, player state, animation and visual representation inside one script.
Solution:: Separate Python modules for Player, Scene, Animation and ColorManager coordinated by the entry point.
Technical role:: Modular organization, interaction logic, scenes and animation with Python.
Value:: The repository demonstrates functional decomposition across six Python sources instead of one monolithic script.
What you can inspect:: Public code with main.py, Player.py, Scene.py, Animation.py and ColorManager.py.

In practice: Modular Python organization for scenes, player state and animation, separating interaction logic and visual representation into independent modules.

Open technical case

GitHub

Confidential industrial experience

Looking for industrial work that cannot be published on GitHub? Architecture, scope and engineering decisions can be discussed on request, subject to confidentiality obligations.

Discuss your project