Hello, I'm Rick! Welcome to another issue of The Rising Dev, a newsletter where I share career experience, insight, and strategy for getting promoted and rising as a software developer. If you're already a subscriber, thank you so much for your support. If you're not - subscribe.


6 Attributes of Highly Effective Software Developers

There are many different ways to be effective as a software developer.

What I’ll be sharing here are the attributes common to those I would categorize as “highly effective,” meaning they did the things that multiplied the efforts of their teams.

Fair warning, this isn’t about being a better coder or leveraging a specific programming language. Coding skills only get you so far; I won’t belabor this point, but I touch on it a bit more at the end.

Here are six of the things software developers do to be highly effective.

✨ Prioritize the End-User

I think it’s safe to say that most of the solutions we propose, the ideas we share, and the hills we choose to die on are products of experience.

There’s nothing wrong with this; it’s what we bring to the table when we are hired. However, my experience has shown me that the best developers usually advocate for the end-user, the customer, when it comes to solutions, ideas, and pushing back.

Code and tech are essential, but highly effective developers know that these can change quickly; they’re a moving target.

Customer needs are relatively constant. Focusing on customer needs as a razor for decision-making is a worthwhile strategy. When everyone else is arguing about code, languages, tech-stacks, and platforms, focus on the customer.

Break Things Down

Good developers are filters.

They take in information, usually in the form of product requirements, and they separate the signal from the noise to figure out the best approach to building something.

Highly effective developers go a step further. They strive to minimize vagueness for themselves and others.

One way they do this is by breaking down large rocks into smaller pebbles. The smaller parts are easier to analyze and plan around.

Smaller pieces can be chunked in different ways. Effective developers understand that once something is broken down, the elements can be grouped and approached in a way that minimizes risk, cost, or the time needed to build.

Assess the tradeoffs

All software developers, regardless of their level, can assess tradeoffs; but it takes a more intentional developer to do this well.

Highly effective developers keep specific questions front of mind. These questions can mean the difference between building the right or wrong things and building those things the right or wrong way.

Here are some of the tradeoff questions considered by effective developers.

  • Do we prioritize quality, cost, or speed; we can’t do all three?
  • Can we buy what we need, or buy some of it and build the rest?
  • What’s the opportunity cost? What gets missed if we do this?
  • What's the space/time tradeoff, how do we prioritize storage, memory, and processing speed?
  • What are the data consistency needs? Can we leverage eventual consistency, or do we need real-time data updates?

You’ve likely run across many others. Highly effective developers keep these kinds of questions at the ready.

Collaborate Well

This attribute is the most important; the quality of your collaboration is encoded into the work you do—if your collaboration sucks, your work sucks.

Collaborating well can include many things, but I think the following three are at the top.

  • Communication: Whether written, spoken, or over a zoom call, effective developers prioritize communication. They build partnerships with other disciplines, and they nurture an open line of communication. Effective developers broadcast information so that surprises are kept to a minimum.
  • Active Listening: Effective developers listen to understand, not to respond. This is part of their curiosity and empathy. They are eager to know how others think and feel. They ask questions to understand people at a deeper level and partner with them to move forward productively.
  • Psychological Safety: Collaboration is a two-way street, and effective developers understand that the more input and feedback they get, the higher quality their efforts will be. A way to get good feedback often is to create a safe place for others where trust and rapport can be built without fear of judgment or retaliation.

Collaboration is the glue; without it, the other attributes fall short.

Go Deep and Broad

As a generalist, I prefer to have a broad understanding of many things.

Having a breadth of knowledge can help you find the patterns within an otherwise chaotic world or project. Finding dependencies within the work you do quickly is often the result of broad knowledge across different code areas or a tech stack.

Effective developers can also go deep; their breadth of knowledge is augmented by deep domain knowledge or a specialty.

Deep knowledge makes you a great coach and mentor; it’s often the result of years of practice in one or a few specific areas. Consider where you will specialize and where you will go broad.

Stay Curious

Curiosity is a beautiful trait to have.

It’s a barrier to setbacks and challenges. Curious people are undaunted by pitfalls and surprises because their curiosity empowers them to see unlimited possibilities.

From analyzing and vetting new tools or code libraries to pivoting focus from one mission to the next, curious people want to see what might be hiding around the next corner.

If you find yourself frustrated by tasks that come in sideways, a canceled project, or the unpredictability of your roadmap, ask yourself if you’ve lost your curiosity.

Reignite that curiosity by finding the lessons in current situations. Effective developers ask questions to find out why things are the way they are and to unearth that nugget of knowledge a new path might bring.

Why I Didn’t Mention Coding

There’s a lot to be said for being a great coder, but I didn’t emphasize this because great code won't stand on its own.

If you’re not prioritizing the end-user, breaking things down for clarity, assessing the trade-offs, or collaborating well, how good will your coding efforts really be? While bad code can ruin a project, great code won’t make a project successful.

Code isn’t a force-multiplier for your team, but the attributes above are.


📖  Flywheels For Momentum

I’ve been rereading a book called Turning The Flywheel by Jim Collins. It’s a companion to his book called Good to Great.

Turning The Flywheel

This book is a deeper dive into the Flywheel principle. The flywheel principle is about the repeatable series of steps you go through to build momentum, first slowly, then to a point where the momentum becomes incredibly difficult to stop.

Here’s a flywheel example for Amazon:

Turning The Flywheel by Jim Collins
Source: Turning The Flywheel by Jim Collins

I’ve been thinking about flywheels a lot lately, especially as a way to build momentum around personal and career goals.

The book has an excellent section on how companies can ask the right questions to figure out the 5-6 steps for their flywheel.

I’m thinking I can translate those questions so they relate to personal and career goals and begin creating some flywheels of my own to build momentum.

I’m still in progress on this, but I’ll share some of my examples when they’re ready.