Fixing Bugs vs Hiring Developers: A Cycle of Compounding Costs

Your senior engineers spend more time answering questions than writing code. Every new hire triggers the same cycle. "Where's the endpoint for user permissions?" "Why does the orders service handle auth differently from the payments service?" "Which response format are we supposed to use I've found three." The senior developer stops what they're doing. Context switches. Walks through the codebase. Explains decisions that were never documented. Gets back to their own work 45 minutes later and has to rebuild their mental state from scratch. This happens two or three times a day. Multiply it across every new hire this year and your most experienced engineers have lost weeks of deep work to explaining things that should be self-evident from the codebase. The problem isn't the new hire's ability. The problem is that your API layer requires an oral history to navigate. Picture LEGO with instructions on every piece. A new builder doesn't need someone standing next to them explaining where each brick goes. The structure communicates itself. They see a pattern, follow the pattern, extend the pattern. Standardised building blocks make the architecture self-explanatory. Consistent endpoint structure. Governed naming. Auto-generated documentation that reflects the actual state of the system not a wiki page from seven months ago.

It's such a great time to be a Software Engineer ☀️! Everyone's talkin how they don't write code anymore and the multiple "apparent" problems that come from that, but I see it differently. Thank god we no longer do, because most of that code was Donkey Work– writing Reat Hooks, rendering lists, sharing state between HoC, yeah all novelty work/or not after you did 1000 times. I still write code, I just do less dumb work. As a highly ranked engineer, I used to feel unease at times, burning time to write some React logic, investing time in wiring jest or vitest to ensure my code was being tested properly and so on. I was great at it, but we all have been there 45 minutes in, on something for which we only had 5 minutes, given the value we were expected to deliver. Plus, good engineers have pride in what they build, and so it's easy to often invest a bit more time than the value it delivers to our customers. But we accept it because we feel good about it sometimes, that feeling of "job well done". Some other times, we just have to trade off. I'm incredibly happy that I no longer have to trade off. It's much faster to create and explore, faster to get PoCs production-ready, faster to build it right, without killing our customers with anxiety.

Architects: Stop trying to be the "Super-Developer." The biggest request I hear from devs is: "I want my architect to code with me." I understand the need for credibility, but there’s a trap here. If you spend your day coding to stay "busy," you aren't fulfilling your actual mandate. An Architect’s real job is to: 1️⃣ Connect technical reality to business value. 2️⃣ Negotiate with management to prioritize tech debt. 3️⃣ Act as the technical North Star for the product. You can't do that if you're stuck in a 4 hour debugging session. Pro-tip: Stay humble. Your devs will become more technically proficient in the day-to-day than you. Let them. Your value is now measured by the clarity of the roadmap, not the lines in the repo. Agree or disagree? Let’s talk in the comments. 👇

𝗧𝗵𝗲 𝗟𝗼𝗻𝗲𝗹𝗶𝗻𝗲𝘀𝘀 𝗼𝗳 𝗕𝗲𝗶𝗻𝗴 𝗧𝗵𝗲 𝗢𝗻𝗹𝘆 𝗗𝗲 v 𝗶𝗻 𝗧𝗵𝗲 𝗥𝗼𝗼𝗺 You are the only developer in a company full of people who don't speak your language. You feel a specific kind of loneliness that has no name yet. It's not the loneliness of working remotely or being an introvert in an open-plan office. You started to notice this loneliness when you had no one to review your code. You merged your own code and reviewed your own architecture decisions. You had conversations with yourself dressed up as documentation. As the only developer, you never get to be junior again. Every decision is final until it catastrophically isn't. You can't tell anyone at work about your uncertainty because to them, you're the expert. You sit in meetings where someone is explaining a problem using words that mean something different to you. You smile because explaining why it's not that simple requires first explaining what a system even is. You become the IT department by accident, responsible for things nobody assigned you. You say yes because you're kind, but something quietly breaks inside you each time. The thing that actually hurts is the absence of intellectual companionship. You haven't had a conversation with someone who deeply understands what you're building in months or years. You go to online communities to feel less alone. You doubt yourself in strange ways, wondering if the way you think about problems is normal. But here's the thing: there are thousands of you out there. You are the quiet layer, the ones who translated "we need a thing" into a thing, alone. To the only dev in the room, your instinct to Google things isn't weakness, it's self-reliance. The code you wrote alone counts, and it took courage. Share your story in the comments. What was it like being the only dev at your company? Source: https://lnkd.in/gG2ib5kM

The hardest part of a developer’s first job is not coding. It’s understanding the codebase. Thousands of files. Unknown functions. Little documentation. Most developers struggle here. The best engineers do something different. They ask questions early. Curious What confused you most in your first project?

A friend asked a room of software developers: > Why were we insistent on a second person code reviewing every line written by a senior developer, but we're okay with letting "AI" write, review & deploy code which technically "works" but is brittle and error prone? You may think my answer over-dramatic, but I think it's self-evident: For many folks it was never about quality or trust, it was about contempt for other humans' intelligence and maintaining control. We achieved alignment only in process (we require code reviews), not in values (multiple perspectives increase quality and building trust is important). If you skip deeper conversations to find out *why* you agree on something, eventually you're going to get bitten by sociopaths who hold bad software & their CS degree in higher esteem than their peers and employees. This is the most important thing to learn in an interview process, and what you miss when you write "technical challenges" that only grade on whether it works, not why you prioritized what you did.

Most production issues aren’t coding bugs. 🚨 They’re decision bugs. Systems rarely crash because someone forgot syntax. They fail because: • Scale wasn’t considered early • Edge cases weren’t discussed • Monitoring was added too late • A “temporary” shortcut became permanent • Complexity quietly increased ⚙️ In development, everything works. In production, everything is tested by reality. The code might be correct. But the architecture wasn’t ready. Great backend engineers don’t just write logic. They think about load, failure, retries, and observability ⚡ Because reliability isn’t about perfect code. It’s about smart trade-offs. Have you fixed a production issue that wasn’t actually a coding mistake? 🤔 #BackendEngineering #SystemDesign #SoftwareArchitecture #TechCareers

Most people still think writing code is the job. That is the easy part. The real work starts before you type a single line, and it is not finished when the code compiles. Software development is a messy loop of figuring out what actually matters, who actually needs it, and what will break when you ship. The hard part is translating chaos into something people want to use more than once. Plenty of engineers can crank out code. Very few can spot the hidden friction, the dead ends, the features nobody will care about in six months. Code is just the byproduct. Nobody cares how elegant your functions are if the app still frustrates users. Stop fetishizing code. Start obsessing over outcomes. Do your users even notice when you ship? If not, you are just rearranging code for your own amusement. That is not engineering. That is tinkering. Build things that matter. Everything else is noise.

I'm not a developer. I don't write code. I can't tell you every technical limitation of our backend. And sometimes I help plan features that need to be completely rethought. That last part used to bother me. When I first transitioned into Product, I helped plan a new feature. I worked within what I thought were our system's limitations, and a developer spent real time building it. Then, during an internal review, our system architect challenged everything. "This process shouldn't be on this screen." We needed to rethink the entire project after already spending dev time on it. It felt like a failure right at the beginning of my role transition. But it was far from that. We resynced on what we actually wanted out of the feature. With a fresh perspective on how it could exist in our system, we made a pivot, built a quick prototype, and presented it to a merchant who it would impact. They loved it. We moved forward with the new build and still delivered on time...even after "wasting" time on a version that wasn't right. Except it wasn't a waste. That first attempt, and the input from our architect, helped us release something more refined and easier to navigate than we would've built otherwise. Here's what I learned: you're not going to get it right the first time. Trust the people around you. Contribute what you know to the best of your ability. Everyone benefits in the end. Grateful to be part of such a collaborative team.

Most developers think their job is to write code. But the real job is to remove confusion between what the user wants and what the system does Happy weekend.