Career notes
What this job actually looks like, and how I think about it.
-
Why your best work happens when you're not at the keyboard
The walks, the showers, the runs. Hard problems unblock when your conscious brain stops chewing on them. Why protecting non-coding time is part of the job.
-
When to leave a job (and when to stay)
The signals that mean it's time to go and the ones that just mean you're having a bad month. A framework for the decision people most often get wrong.
-
How to make your work visible without being a self-promoter
The quiet engineer's playbook. How to make sure your work is seen and credited without turning into the LinkedIn-bro who can't stop posting about their PRs.
-
Learning how to learn: my notes from the course everyone should take
Notes from Barbara Oakley and Terrence Sejnowski's famous Coursera course — how memory works, why procrastination hurts, and the tricks that actually help you learn faster.
-
Freelance vs permanent: what the recruiters leave out
The real trade-offs of going freelance with a partita IVA in Italy vs staying permanent — money, taxes, freedom, risk, and the stuff nobody mentions until it's too late.
-
How I became a data engineer without a CS degree
My path from the University of Turin to Spark clusters and Databricks certifications — the detours, the lucky breaks, and what I'd tell someone starting today.
-
What I actually do as a data engineer
A plain-language tour of what a data engineer's day looks like — pipelines, plumbing, and the parts that don't make it into job postings.
-
The unsexy power of consistency
Most career advice is about heroics. The truth is more boring: showing up, doing the work, finishing what you start. Why consistent C+ effort beats sporadic A+ effort.
-
Pair programming with people who think differently
Why the best pair-programming session is with someone whose brain works differently from yours. And the techniques that turn 'I'll drive' into 'we both got smarter'.
-
The stupid question reflex: why curiosity beats ego
Senior engineers ask the questions juniors are afraid to ask. The cost of a 'stupid' question is 30 seconds. The cost of NOT asking can be a quarter of work.
-
Owning what you build: the end-to-end mindset
Why the engineers who get promoted are the ones who care about the dashboard at 3am, not just the merge button at 6pm. Owning a thing means seeing it through.
-
How to give feedback that doesn't ruin Tuesday
Code review and 1:1 feedback patterns that move people forward instead of putting them on the defensive. The phrasing tricks that took me ten years to learn.
-
The 1:1 with your manager: how to make it actually useful
Most 1:1s are status updates that could have been a Slack message. Here's how to turn the 30 minutes into the most leveraged time you have.
-
Refactor your career like you refactor code
Every two years, run a 'refactor pass' on your career. Same questions you'd ask of a codebase: is the design still right? what would I do differently if I started today?
-
The deadline math: estimates that don't lie
Why your estimates always run long, and what 'add 50%' actually does to a project. Honest math for engineers who hate giving dates.
-
Learning from incidents: blameless postmortems for one
You don't need a 5-person incident review to learn from a bad day. Run a personal blameless postmortem the same evening. Forty minutes saves you years.
-
Reading code is a skill you have to practice
Most engineers spend more time reading code than writing it, but almost nobody trains for it. The techniques I use when I drop into 50,000 lines I've never seen.
-
The first 90 days at a new job: a quiet checklist
What to do in your first three months at a new company so you build trust, learn the codebase, and avoid the rookie mistakes that take 18 months to live down.
-
Over-document your decisions, or future-you will resent past-you
Code says what. Comments say why. Decision logs say WHY THIS, NOT THAT. Without them, every six months someone (often you) makes the same mistake again.
-
The five-minute rule: when to ask for help
Junior engineers ask too late. Senior engineers ask sooner. The five-minute rule lands the right balance and respects everyone's time.
-
Saying no without being a jerk
Senior engineers don't say yes to everything. They redirect, push back, and protect the codebase from well-meaning chaos. Here's how to do it without burning relationships.
-
Why I automate everything I do twice
Once is a fluke. Twice is a pattern. Three times is a script. The rule that turns hours of manual work into seconds, applied to the things you'd never think to automate.
-
The art of writing a good RFC
Why the best engineering decisions are written down before they're made. A practical template for design docs that surface trade-offs and save your team weeks.
-
The 80/20 rule for understanding requirements
Why the best engineers spend more time talking to users than writing code. The questions that turn vague tickets into clear specs.