We had been hunting for two days trying to figure out why the application kept crashing on its own.
The pattern was clear: restart the server, it would run fine for hours, then — without warning — memory would fill up and it would crash. There were three of us on the team. I was leading the project; I was the one who knew the business logic best. Roger was the new guy.
I wasn't there. The exact details I've forgotten — the sciatica I had back then, something with my son, maybe I found out the next day. What I do remember clearly is that I wasn't the one who solved it.
Joel stayed behind. He connected a remote debugger — something I hadn't thought to do — and found the problem in minutes.
Roger's code. A query that loaded every photo record into memory before filtering by ID, even though we already had the ID and only needed one record. The system handled thumbnails for the list view; full binaries only for zoom. But the query didn't know that: it fetched everything first, then searched. Every time someone opened the visit form, the entire photo table traveled into memory. Just a handful of records was enough to bring down the server.
Joel solved it. Overtime hours, unpaid. Well — paid in pizza.
That's why I felt guilty. And I was.
Not because Roger had written that code — he was new, still learning. But because I was leading that project. And whoever leads is also responsible for what the team produces. Not as punishment: as a natural consequence of the role.
I should have reviewed his code before it reached production. I didn't.
I suggested to Carlos — our boss — that we implement peer review as a standard practice. He listened. But we never followed through: too much work, always urgent, always shipping. We also didn't really know how to run it properly — we had the theory, not the practice.
The practice came later. With SCRUM, with DevOps, with pull requests. And at another job, with another team, I started doing code reviews for real. That's when I understood what I had sensed years before, standing in front of that crashed server: a peer review would have caught that bug in thirty seconds. It was obvious. It just needed a second pair of eyes.
Today that conversation sounds different.
With Copilot, that review that used to cost a colleague's time now takes seconds. It's not perfect — no peer is — but it's always available, doesn't have a 4pm meeting, and doesn't get annoyed if you ask the same thing twice.
The cost of peer review dropped to nearly zero.
What didn't drop is the cost of skipping it.
The pair doesn't cost anymore. What costs is not using it.
ArchMindset — software, teams, and what I learned when everything crashed.