DAVIDE GOZZI

I design and evolve software that has to keep working: distributed services, legacy platforms and systems connected to real machines.

Your friendly neighborhood .NET developer.

CV Email LinkedIn GitHub Steam

Role: Software engineer
Range: 9+ years across distributed, legacy and industrial systems
Base: Modena, Italy
Status: currently online

Work

Nine years of moving toward systems with more constraints and less room for error.

2016–2017

StarworkGC

Junior programmer, later particle effects

I started working during my fourth year of high school, mostly because school had stopped being difficult and I wanted problems that didn’t come with a solutions page. StarworkGC was a small independent game startup building games in Unity, and I joined as a junior programmer — later doing particle effects as well.

It’s where object-oriented programming, design patterns and teamwork stopped being school topics. My code had teammates, a build and players waiting on it.

Decision 01Predicting collisions without simulating the futureRead the engineering note →Close the note ↑

Problem: The game needed to warn players early about incoming collisions with asteroids and enemies — far enough ahead to react, precise enough to trust.
Constraint: It had to run inside the frame budget on low-powered machines. Simulating future game states was too expensive and produced timing artefacts.
Decision: I rebuilt the predictor around projected movement and ray-based spatial checks — geometry instead of simulation — and kept the warning window configurable.
What it taught me: A good approximation at the right time beats an exact answer that arrives late.

Unity, C#, real-time constraints, particle systems.

fig. 01 — ray-based collision prediction, Unity

2017

Melazeta

Development intern

A couple of months as a school-work intern on Unity mobile projects: a Winx dress-up app that shipped on the Play Store, plus Unity UI, in-app purchases and some early augmented-reality work. My first contact with constraints that had nothing to do with code — artists with their own deadlines, assets arriving late, a release date that didn’t move. We shipped anyway.

shipped: Winx dress-up app — Google Play

Unity UI, mobile, in-app purchases, AR.

2019–2021

Amaris · Credemtel

.NET backend developer

At Amaris I worked as a .NET backend consultant for Credemtel, on a document-management platform in a banking environment — REST APIs, microservices, RabbitMQ, Elasticsearch and a lot of deeply nested JSON.

The document structures weren’t fixed. They were defined at runtime by an external configuration system and could nest arbitrarily deep, which made reading and writing them correctly a shared problem for every service that touched them.

Decision 02One package for documents that keep changing shapeRead the engineering note →Close the note ↑

Problem: Every consumer — APIs, services, ETL jobs — needed to read and write documents whose structure was defined elsewhere and kept evolving.
Constraint: Consistency between the configuration and the stored data had to hold across arbitrary nesting, for consumers that didn’t know about each other.
Decision: I redesigned the read/write/transform path around a reusable configuration-driven package, so document structure lived in one place and every consumer integrated the same behaviour.
What it taught me: When configuration is the contract, treating it as architecture is what keeps an ecosystem coherent.

.NET, REST APIs, microservices, RabbitMQ, Elasticsearch, ETL.

fig. 02 — configuration-driven document schemas

2021

iSolutions

Full-stack developer

Nine months of full-stack work on established products. No big story — the skill I took away was how to enter an existing codebase, map its hidden dependencies, and make changes conservative enough not to break what already worked.

2021–2023

MSC

Senior .NET developer

I worked on the software that processes container and shipping documentation for one of the largest shipping companies in the world. Parts of the codebase were older than some of the people maintaining it: C# next to C++, stored procedures measured in thousands of lines, components running in installations across the globe. I collaborated daily with colleagues in the United States, including six weeks of in-person knowledge sharing there.

Two problems from those years stayed with me. The first was a manager-and-agent system that distributed DLL-based capabilities — file operations, checks, health activities — to installations around the world, scheduled with Quartz.

Decision 03Shipping capabilities to installations you cannot update predictablyRead the engineering note →Close the note ↑

fig. 03 — manager and agents, Quartz scheduling

Problem: A central manager distributed DLL-based capabilities to agents installed around the world, and had to know from a distance whether each one was healthy.
Constraint: Some installations could realistically be updated once. Whatever we shipped had to keep working next to the oldest contracts still alive in the field.
Decision: We treated backward compatibility as the primary design input: explicit dependency loading, Quartz-based scheduling, and health reporting so an agent’s state was never a guess.
What it taught me: In globally distributed systems, compatibility is availability.

The second was less glamorous: a document flow between a third-party service, our central application and SAP, communicating through shared Windows folders. You don’t always get to choose your infrastructure. What you can do is make it observable — where each document is, where it got stuck, on whose side it failed. I coordinated the implementation across a group of four people.

C#, C++, SQL, stored procedures, Quartz, SAP integration.

2024–today

GIAMMAR · System Ceramics

Software engineering consultant

Since 2024 I’ve been consulting on industrial software for System Ceramics through GIAMMAR — systems that talk to physical machinery in ceramic manufacturing plants. Data flows from PLCs and vendor protocols up through custom connectors into modern .NET services, Redis and RabbitMQ; decisions flow back down to the line.

The project I keep coming back to is a quality pipeline. A machine photographs tiles and detects surface defects; the software has to turn that stream into decisions.

Decision 04Turning detected defects into usable tilesRead the engineering note →Close the note ↑

Problem: Defect data arrives from the machine as images and detections, in real time, while production keeps moving.
Constraint: The same data serves two clocks: immediate decisions on the line — including the largest usable tile area that avoids the defects — and long-term traceability across production history.
Decision: We treat the defect stream as durable data rather than transient signals: imports can be reprocessed, the usable-area computation is repeatable, and storage is designed for analysis years later.
What it taught me: Real-time and long-term aren’t competing requirements — they’re two consumers of the same well-designed data.

The other half of the job is lower level: connectors and drivers that speak to machines at the byte-stream level — serialization, memory areas, vendor protocols — and expose interfaces the rest of the system can use without knowing any of that.

.NET, Redis, RabbitMQ, OPC UA, PLC, binary protocols.

fig. 04 — defect map and largest usable area

AI-assisted development

My background is backend; interfaces were the part I used to hand to someone else. AI-assisted development changed that — not by replacing judgment, but by making me faster exactly where I had the least muscle memory. This site is a concrete example: built with an AI pair, with me setting the direction, reviewing the implementation and owning the final result.

My core territory

Backend, architecture, distributed systems, integration with machines.

Extended with AI

Interface implementation, interaction prototyping, visual iteration.

Still my responsibility

Architecture, verification, tests, security, trade-offs — and what “done” means.

OSUS

A small independent lab where I build the products I keep thinking about. Four projects so far — separate ideas, one ecosystem.

RosettAI

An asynchronous translation platform for documents where everything except the language must survive: layout, structure, embedded data. Built around observable processing, validation, retries and fidelity checks.

active build

rosettai.osus.it — live ↗

FCHForge
Makes industrial feed-collector configuration visible and manageable.
pre-alpha
OSUS Ecosystem
Shared identity, trust and integration layer for the other projects.
pre-alpha
Sounds
Music, played together.
pre-alpha

Credentials

English — C2 comprehension, EF SET 84/100 (reading 78, listening 90). The certificate covers reading and listening comprehension. Verified certificate

Education — IIS F. Corni, Modena. Diploma di perito informatico.

Contact

Email is the most reliable way to reach me. I read everything, including the interesting problems.

CV (PDF)david3gozz1@gmail.com LinkedIn GitHub Steam