Experience, in Practice

1. Experience is getting comfortable with ignorance. Experienced developers embrace ignorance, but know they must always learn. They deliberately choose what to learn and focus on understanding how things work so they can apply them in the right context.

• A junior says, “I want to learn this new framework everyone is talking about.”
• A senior says, “What am I ignoring that I actually need to understand?”

2. Experience is thinking beyond the present. Experienced developers know that no line of code or no dependency is free. When junior developers focus on the present, senior developers prepare for the future.

• A junior says, “I can build this in minutes.”
• A senior says, “Do we want to maintain this for years?”

3. Experience is reducing accidental complexity to embrace incidental complexity. Experienced developers ensure that the product can support the complex features that will make a difference for users. They prefer using existing tools well over adding new ones, preventing architectural chaos.

• A junior says, “We should add Redis for caching.”
• A senior says, “What can PostgreSQL already do?”

4. Experience is considering drawbacks (as much as benefits). Experienced developers look for what a new technology can bring and the limitations that come with it. They’ve lost the illusion that there’s a “right” solution. Experience is about finding the trade-offs you can sleep with.

• A junior says, “We need to use this new popular technology.”
• A senior says, “What will become more challenging if we use it?”

5. Experience is thinking about second-order consequences. Experienced developers don’t only solve the immediate problem. They reflect on how every code change affects the system—and how it will affect the codebase for the following problems to address.

• A junior says, “Let’s fix the SQL query”
• A senior says, “How will that affect the API load?”

6. Experience is learning from decisions. An experienced developer remembers what “good decisions” cost one year later or at 3 a.m. during an incident. Experience sometimes means making boring decisions. Most successful sites are still built using proven technologies. The product should be innovative—not the codebase**.**

• A junior says, “Everyone talks about this new GitHub project”
• A senior says, “Does it give us a real competitive advantage?”

7. Experience is saying no, even when it’s easier to say yes. Experienced developers understand the business value of every feature but encourage smaller steps to welcome the new feature without increasing the technical debt.

• A junior says, “Yes, I’ll do it”
• A senior says, “Should we redesign this first?”

8. Experience is knowing where to apply effort. Experienced developers understand time is always the scarcest resource. They know which bugs matter, where performance counts, and what must be fixed first.

• A junior says, “I found a bug to fix.”
• A senior says, “How long has the user lived with it?”

9. Experience is about leadership. Experienced developers lead by example. They don’t impose their ideas, thinking they were hired because they are smarter than others. They demonstrate humility, align their words with their actions, and aren’t afraid to ask stupid questions, or admit mistakes.

• A junior thinks, “I don’t know.”
• A senior says aloud, “I don’t know, but we’ll find out.”

10. Experience is welcoming feedback and giving feedback. Experienced developers have acquired different skills over time and know feedback is about finding opportunities to improve them even more. Experienced developers know how to give feedback too. They first build trust so the other person feels believed in—because they genuinely do believe in them.

• A junior says (to himself), “He never listens when he has an idea in mind.”
• A senior thinks the same but finds the opportune moment to challenge that person: “How could you avoid being anchored on your initial idea?”

11. Experience is about solving the right problem. Experienced developers don’t try to solve all problems. Not all problems are equal. In addition, they invite perspectives so that the best idea wins.

• A junior says, “Here’s the solution.”
• A senior says, “What are our options?“

12. Experience is knowing principles are more important than rules. Experienced developers prioritize principles over rules to encourage critical thinking.

• A junior says, “Every change requires two reviewers.”
• A senior says, “How do we handle hotfixes during on-call while ensuring changes are reviewed afterward?”

Experience, Redefined

None of the previous points requires long years of experience. I’ve seen young developers understand them naturally and I repeatedly see older developers still behaving like juniors.

As outlined by the previous examples, experience is not having more answers, but asking better questions. Questions are more interesting than answers. Good questions are what help people grow and create opportunities. Both are crucial for helping a team develop experience over time

True software experience isn’t measured in years or technologies listed on a résumé. It is measured in judgment. And judgment is built through reflection—especially on failure, starting with your own.