Luca Spaghetticode
Luca

Software architect & network R&D engineer. Interested in the quiet parts of the internet β€” routing, control planes, and the systems no one notices until they break.
Based in Munich, Deuschtland πŸ‡©πŸ‡ͺ
Currently open to new roles 🌍

About

I spent my first year writing application backends and slowly realised the interesting bugs lived two layers down. Now I work mostly between L3 and L7 β€” routing, service meshes, and the quiet protocols people lean on without thinking about.

I write essays about boring infrastructure, ship side projects that are at least 40% jokes, and am slowly being convinced that the hardest part of distributed systems is the part where humans agree.

Work

Education

M.Sc Computer Science & Engineering Β· CIT
TU MΓΌnchen, Germany β€” Exchange semester
Mar – Oct 2024
M.Sc Computer Science Β· ICT Solution Architect
University of Pisa, Italy
2022 – 2025
B.Sc Computer Science
University of Pisa, Italy
2018 – 2022

Fun

EU Space for Defence and Security 2024 - Cassini Hackaton Β· 3rd Place Winner, Czech Republic, ESA Innovation Centre
2024
Mentee Β· Each mentor is a high-impact person from industries like Apple, Adobe, Epic Games, Meta, Microsoft, Netflix, Nvidia, Twitter
2022

Projects

kdense2022

Writing

Contact

Pass by to sai hi!

Β© 2026 Luca Spaghetticode Munich Β· CET
← index
Project Β· 2024 Β· Principal architect

Latency-aware routing layer

A region-aware policy mesh that sits between the application layer and the network, choosing routes by real-time latency instead of static config.

RolePrincipal architect
Year2024 β€” present
StatusProduction Β· ~40 clusters

Context

At Nimbus, cross-region traffic was routed by a 12k-line monolithic policy engine. It was correct, and it was unbearably slow to change β€” every adjustment was a release, every release was a small ceremony.

What I built

A per-region control plane in Go, programming the data path with eBPF and exchanging reachability over BGP. Three focused services replaced the monolith, each one small enough to reason about on a whiteboard.

The goal was never to be clever. It was to make a routing change feel as cheap as it actually is.

Outcome

p99 cross-region calls dropped 38%. Config changes that used to take a release now take about a minute. Patent pending on the bidding algorithm that picks between near-equal paths.

← index
Project Β· 2022 Β· Author

Looking-glass v2

A public, safe-shell BGP looking glass β€” let anyone inspect routing state without handing them a router.

RoleAuthor
Year2022
StatusLive Β· public

Context

Network operators needed to debug reachability from our edge, but giving shell access to a production router is a non-starter. The previous looking glass solved this by being read-only and barely usable.

What I built

A Rust service that brokers a tiny, rate-limited command set over WebSockets to a sandboxed routing view. No raw shell, ever β€” just the handful of show commands that actually answer questions.

Outcome

Adopted by about half the regional carriers in Europe. Zero incidents traced back to it in three years, which for a public window into production is the only metric I cared about.

← index
Project Β· 2022 Β· Maintainer

kdense

An open-source Kubernetes density planner. Finds the smallest fleet that still fits your SLO.

RoleMaintainer
Year2022
StatusOSS Β· maintained Β· ~2.4k β˜…

Context

Capacity planning for Kubernetes was tribal knowledge and spreadsheets. I wanted a tool that argued from the SLO backwards rather than from last quarter's node count forwards.

What I built

A Go CLI that models pod resource shapes and packs them against candidate node types, returning the cheapest fleet that still holds your latency and headroom targets.

Outcome

About 2.4k stars and a steady trickle of issues from people running it in anger. Used in a few conference talks I did not give.

← index
Project Β· 2023 Β· For fun

Spaghetti.app

An altitude-aware pasta timer with strong opinions about al dente.

RoleSolo, for fun
Year2023
StatusOn the App Store

Context

Water boils cooler at altitude; pasta packaging assumes sea level. My nonna was, correctly, furious about a batch of penne I ruined at 1,400m.

What I built

A small Swift app that reads your elevation, adjusts the cook time, and then refuses to be quiet until you actually drain the pot.

Outcome

14k downloads in a week, then I forgot about it. Strong, unsolicited endorsements from grandmothers. Still my highest-rated piece of software.

← index
Project Β· 2025 Β· Author

Quietnet

A tiny mesh VPN. Two binaries, one config file, zero opinions about how you should hold it.

RoleAuthor
Year2025
StatusOSS Β· early

Context

Existing mesh VPNs were either too magic or too much. I wanted something I could read in an afternoon and explain to a friend in five minutes.

What I built

A Rust implementation in two small binaries β€” a coordinator and a node β€” sharing a single TOML file. No control plane to run, no dashboard, no account.

Outcome

Runs my homelab and a handful of friends' networks. Still under 5k lines, which is the whole point.

← index
Essay Β· March 14, 2026 Β· 14 min

A short defense of boring infrastructure.

Most of the outages I've cleaned up came from someone reaching for novelty. Here's the case for the dullest possible stack β€” and when to break that rule on purpose.

I have a folder on my laptop called incidents/. It is the closest thing I have to a religious text. Every entry is some version of the same story: a team needed to ship a thing, an engineer reached for a tool that was newer than their experience with it, and at three in the morning on a Saturday, someone called me.

Over the years the names changed β€” service mesh, then GraphQL gateway, then a particularly enthusiastic Kafka topology, then a vector DB used as a primary store β€” but the structure didn't. The exciting tool was supposed to save us six weeks. It cost us six months and a person.

What I want to argue is something close to a moral position: your default should be boring. Not because boring is correct, but because boring is cheap to be wrong about.

What I mean by boring

By boring I don't mean old. Plenty of old technology is also bad. I mean: tools you can debug at 3am without reading documentation; tools where the failure modes are folkloric β€” the team already tells stories about them; tools where the next hire has used them before.

The cost of a tool isn't how long it takes to install. It's how long it takes the fifth person on the team to fix it at midnight.

Postgres is boring. cron is boring. A shell script behind a systemd unit is boring. None of these are correct in every situation β€” but they have the rare property that the worst case is well-understood.

When to break the rule

I'm not religious about this. There are three situations where I happily reach for the new thing:

  1. The boring tool is structurally wrong, not just slow.
  2. You have two engineers who have shipped the new tool to production before, at scale, and they're both on this team.
  3. The new tool replaces something that has caused you measurable, repeated pain β€” and you can name the incidents.

Note that “it's on the front page of Hacker News” is not on this list. Neither is “we'll learn a lot.” You will learn a lot from running anything in production. The question is what you'll learn it about.

The senior trap

I am no longer the person who would benefit most from learning the new tool. I am the person who would benefit most from not having to learn it at 3am. There's a temptation, when you reach a certain seniority, to mistake your team's curiosity for your team's judgment.

# the wrong question
> Should we use $NEW_THING?

# the right question
> What does our worst week look like
> if we use $NEW_THING vs. what we have?

I keep that diff in my notes. I look at it before approving an RFC. It is the single most useful piece of judgment I've developed in twelve years.


None of this is an argument against curiosity. Build the weird thing on the weekend. Just don't put it on the load path before you've put it through your own worst case. Boring is a kindness to your future self β€” and to whoever has to call you at 3am.

β€” Luca, somewhere near Bologna.

← index
Note Β· February 02, 2026 Β· 9 min

The four shapes of an on-call rotation.

Every on-call rotation I've sat in falls into one of four shapes. Knowing which one you're in tells you what to fix first β€” and what to stop trying to fix.

I've been on call, in one form or another, since 2017. Across four companies and three time zones, I've learned that the shape of a rotation matters more than any of the things people argue about online.

By “shape” I mean the distribution of when, why, and how often pages happen. Most teams fall into one of four. Each has a different remedy.

The cliff

Long, quiet stretches. Then, every six to eight weeks, a brief, terrifying cascade. Then quiet again. The team forgets how to be on call between events. You don't need more alerts. You need regular, scheduled, mundane practice.

They don't need a runbook. They need a memory.

The drip

Three to six low-severity pages a night. None are real outages. All are real interruptions. The drip is almost always a signal-to-noise problem, which is to say, an ownership problem.

The grind

Two or three real, painful incidents a week. The team is competent β€” they fix it every time β€” but they are also clearly drowning. The grind is structural. You need an architecture conversation, scheduled during the day.

The fog

Almost no pages, but everyone senses the system is unhealthy. Usually your alerting is too coarse. The fix is rarely more alerts; it's a weekly twenty-minute review where one person looks at the boring graphs.


The first useful question, when you join a team, is not how many alerts do we have. It is what shape are we in. The second is whether anyone has slept this week.

β€” Luca, somewhere near Verona.

← index
Essay Β· January 18, 2026 Β· 7 min

Why I stopped writing tickets like Jira asked.

Tools shape thought. Jira kept asking me for the wrong things β€” so I started answering different questions instead.

A ticket template is a small argument about what matters. Jira's default template argues that what matters is a title, a priority dropdown, a story-point estimate, and a wall of fields nobody reads. I went along with this for years.

Then I noticed that every ticket I actually enjoyed picking up had the same three things, and none of them were in the template.

What a good ticket actually says

It says what is true now, what should be true instead, and how we'll know we got there. That's it. Everything else β€” priority, points, labels β€” is metadata for a spreadsheet, not for the person doing the work.

If I can't write the “how we'll know” line, the ticket isn't ready. It's a wish.

The reframe

So I started writing the description as three short paragraphs and leaving the fields mostly blank. The current state, the target state, the signal. My tickets got longer to write and much faster to pick up.

Nobody has complained that the story points are missing. Several people have told me they wish more tickets read like a sentence someone meant.

β€” Luca, between two stand-ups.

← index
Essay Β· December 09, 2025 Β· 8 min

TCP, but for conversations with juniors.

Flow control isn't only for networks. The best mentoring I've done borrows, almost directly, from how TCP behaves.

TCP doesn't blast data as fast as it can. It sends a little, watches what gets through, and adjusts. The whole protocol is an apology for the fact that the other end has a finite buffer.

I think about this a lot when I'm mentoring. Early in my career I would blast β€” dump everything I knew about a problem in one go and feel useful. The buffer on the other end would overflow, and most of it would be dropped.

Slow start

Now I open small. One idea, then a pause to see what comes back. If they ask a sharp follow-up, I widen the window. If they go quiet, I back off and resend more simply. The acknowledgement is the whole signal.

You are not measured by how much you said. You are measured by how much arrived.

Congestion

And when something goes wrong β€” a missed concept, a frustrated silence β€” the move is the same as the network's: slow down, don't resend louder. Loud is not a retransmission strategy. It never was.

β€” Luca, drawing windows on a whiteboard.

← index
Note Β· November 22, 2025 Β· 6 min

A small grammar for incident reviews.

Most incident reviews fail because they argue about facts. A shared grammar fixes more than a template ever will.

The worst incident reviews I've sat in spent forty minutes disagreeing about what happened before anyone could say why. The fix wasn't a better template. It was a small shared grammar β€” four words everyone agreed to use the same way.

The four words

Trigger: the thing that changed. Condition: the latent state that made the trigger matter. Impact: what users actually felt. Signal: how we found out, and how late.

A deploy is a trigger. A missing back-pressure limit is a condition. The two are not the same sentence, and reviews fall apart when we pretend they are.

Why it works

Once everyone slots their version of events into the same four buckets, the disagreements get smaller and more honest. You stop arguing about blame and start arguing about conditions β€” which are the only thing you can actually go fix.

β€” Luca, in a meeting room that needed more coffee.