The manager’s job

Part 6 in a series on managing programmers

It’s my experience that many technical managers aren’t — and don’t really want to be — managers. See, we generally start out as engineers or developers, and probably show some strong competence as individual contributors. Maybe we’re also one of those rare engineers who can keep their cool with customers and has a knack for explaining technical solutions to non-technical types. Then something happens — someone resigns, a team gets too big, a new project starts — and we’re thrust into the job of “leading a team”, perhaps “just in the interim”. And we try to continue doing things like we had been doing, but now we’ve got all these extra meetings to go to and emails to answer and we have to hang out with the guys in sales and marketing and the project manager keeps asking me questions about when we’ll be done and I have all this PTO to approve and then Sally’s dog died and Jason’s getting married and I’ve got hire an intern for the summer and all I really want to do is write code!

This isn’t the fault of the poor sap who just got thrust into management. This is a problem with the organization, because most organizations don’t pay enough attention to succession planning and training their managers. I find this is a problem with how most places define the role of manager, and how they expect to find manager. Put simply: The best engineering managers aren’t normally the best engineers on the team. Sure, they can do the work, but they’re more often the guy or gal on the team who knows exactly who else in the organization might be better at a given task than they are. So I wanted to share some of my thoughts on what the job of technical manager actually is and isn’t.

A manager’s job is about…

  • People. This one’s obvious, right? You saw it coming, sure. But the problem is that most organizations don’t make this point crystal clear to new managers: “Your people are your number one priority. Period.” Not your code, not the new architecture. Your people. Their productivity, their effectiveness, their professional growth, their ability to work as a team, and, yes, even their “happiness” is your single most important responsibility. That means your job is to listen more than you talk. That means if someone on your team wants to talk to you, you should very seriously consider dropping everything else on your plate to have that conversation. That means everyone on your team should have your cell phone number and personal email address. That means emails from folks on your team are the very first emails you read and respond to (and yes, you always respond!). That means you make time to meet with everyone on your team one-on-one in private at least once a week, and that your weekly team meeting is something you prep for and retrospect on afterwards. That means thinking about how to resolve interpersonal conflict between your team members is something that keeps you up at night. That means you are concerned with the professional development of your team members over the long term, not just with their performance in the moment. And yes, that means all these things are more important than you getting to write code or build robots.

  • Productivity. Ultimately, your job is to help the folks you manage be as productive as possible. This is a good thing for the company, obviously, but it’s also a good thing for the people on your team. Studies have shown that happy people are not necessarily more productive, but that productive people are usually happier. This makes sense: If you can help the folks on your team get stuff done, then they are rewarded by a sense of accomplishment and having made a real difference that day. So, when considering someone for the manager role ask: Is this someone who by hook or by crook makes other folks more productive? Are they the ones you find moving the furniture, putting away the dishes, making sure the coffee is hot, walking over to marketing to get clarity on deadlines, and running interference with the sales team — just so that the folks doing the work can have the physical space, mental tools, and emotional focus to be effective and productive?

  • Priorities. One of the ways you help make your people more productive is by being creating exceptional clarity around priorities — both for the folks on your team and the stakeholders outside your team. Ask around and you’ll find that most developers have a half dozen “top priorities” at any given moment. But again, studies have shown that most of us are actually pretty terrible at multitasking, so it’s just wrong to believe that someone with more than one (or maybe two) priorities is actually going to be effective. One of a manager’s most important jobs is to stretch those half dozen tangled priorities out into a clearly ordered list, and then share that list with everyone. So is your manager always the one ordering and re-ordering and clarifying and communicating priorities? And making sure everyone knows what everyone else is working on and why they won’t/can’t/shouldn’t get to priority number seven until two weeks from now? They should be.

  • Positivity. Engineers are problem solvers, and therefore problem-oriented. It’s very easy for most of us to identify what’s wrong with any possible solution — the risks, the holes, the probability of error, etc. But the danger is that a room full of engineers can drift toward negativity and inaction (we are also a data-driven lot, and there’s almost never “enough” data). The manager’s job is to keep the team focused on the positives, help the team create a workable plan, and drive toward an acceptable solution. You are not necessarily the smartest person in the room, so your job is to get those folks thinking, and thinking about solutions not roadblocks. Are you supposed to have a vision, a plan, and be a bit of a cheerleader for your team and the organization? Yes. And are you supposed to smile and give positive feedback for things done right? Yes. Negativity is very easy for engineers, and it’s part of your job to set an example and focus on what can be done and what’s getting done correctly.

  • Teaching. A manager needs to be a teacher, and the job of a teacher is to help their students learn and grow their knowledge and skills. It’s important to note that most great math, science, or history teachers are not themselves great mathematicians, scientists, or historians! Great teachers ask great questions — the kinds of questions that inspire their students to think and rethink, to question what they thought was true, to become curious about alternative paths and different ways of doing things. Likewise, good managers ask more than they tell. “What do you think?” “What are some other ways of doing that?” “Is that really the best/only way to solve this problem?” “How could we do this faster/better/stronger/differently?” Good managers recognize that learning is about the student growth and ask these questions with the intention of leading the team to the best possible solution, not simply to demonstrate how smart they themselves are. Good managers recognize that it’s sometimes okay to let someone choose the wrong path and fail if it helps the larger goal of learning and growth. And good managers are always thinking about how to engineer a better learning process.

  • Trust. We gain trust when we do what we said we’d do. It’s really that simple. And a manager’s job is about brokering trust within her team and within the larger organization. Managers need to trust team members, team members need to trust their manager and each other, and the company needs to trust the team. This all boils down to a process of setting expectations, communicating clearly about those expectations (including letting folks know when they change), and then meeting the expectations you’ve set for yourself and your team.

  • Leading. It’s the manager’s job to stand up and lead. Yes, leading usually means public speaking. It’s your job to run the daily stand-up and the team meeting. And it’s your job to call and order the pizza. And it’s your job to present the team’s latest work at the company demo. And to shake hands with new customers and new employees and meet and actually talk to actual people. Of course, not all of us are great at this part of the job (since many of us are introverts), but it is indeed part of the job. Good managers know that they are always on stage, and everyone is always watching. But leadership is more that just public speaking. It’s also about creating a shared vision and mission for your team. Who are we? Why are we here? Sure, we’re engineers and we’re here to solve problems and get paid. But most high-functioning teams have some understanding of how their group fits within the larger organization, and why the work they’re doing matters. It’s the manager’s job to articulate this vision and help forge this identity through goal-setting for individuals and groups, positive and constructive feedback, and communication with folks inside and outside of the team about how awesome the team is.

A manager’s job is not about…

  • Always having the (right) answer. Your job is to help solve people work together to solve the problem and come up with answers. Most often this means you’re the person who knows the person who might know a person who probably has the answer. The manager’s job is to connect smart people and thereby magnify or focus their impact.

  • Being the smartest person on the team. See above. I’ve worked with some horrible managers who were absolutely brilliant engineers. This, in a nutshell, is why if folks can’t get behind all the “soft stuff”, and can’t bring themselves to “schmooze” and “deal with all the politics” then they’re probably better suited to continue in a role as an amazing individual contributor. The manager’s job is to know who the smart folks are, get them in a room, set some goals, and help them work toward a solution and a commitment to getting the work done. They need to be smart, but they’re probably not the best scientist, engineer.

  • Doing the work themselves. The manager’s key skill is to be able to accomplish more through other people than they would themselves. If the manager is the person who’s constantly called into play to fix the problem, write the key algorithm, or save the day, then something’s wrong. It’s not that the manager couldn’t necessarily do the work. Rather, it’s that the manager is supposed to be leading a team, and when the team does the work the team works better.

  • Perfection. It’s amazingly easy for engineers to let “perfect” become the enemy of “good enough”. Smart managers know that their job is about people, and people are rarely perfect, and rarely produce perfect work. Smart managers know that a solution that meets 80% of the customers needs today is about a million times better than a solution that meets 95% of the needs but gets delivered too late. The 80/20 rule is the right way to approach things about 80% of the time. The fact is that the people who work with you will make mistakes, and the systems will fail. Better to accept this and plan for the inevitable than beat people up for just being human or try to create perfect systems.

Posted: April 17th, 2014 by Neal Enssle
Tags: , , , ,
No Comments »

Different pastures

As many of you know, I’m off to different pastures. I’ve decided to step down from my role as Director of Technology at Foraker Labs and pursue a new opportunity as Software Engineer at Rally Software in Boulder.

Both Tara and I are very excited about this transition. Rally Software is a Boulder-based, medium-sized company focused on selling cloud-based solutions to support Agile engineering methods for name-brand customers like AOL, Boeing, Cisco, Comcast, EMC, Fidelity, PayPal, UnitedHealth, and Yahoo!. Rally consistently wins awards for “best company to work at”, and their core values resonate with me. And I’m extremely excited (and a little nervous!) to be returning — once again — to a role that is focused more on getting my hands dirty building software. I really enjoyed getting to know some of the team during the interview process, and I look forward to the opportunity to join and learn from Rally’s team of amazing engineers.

Yet the parting is obviously extremely bittersweet. After more than six and a half years, I’ve made many, many friends at Foraker. I am enormously grateful for the support, guidance, encouragement, and tremendous opportunity I received during my tenure. I had so many teachers, including many from among our customers. I thank all of them for allowing me to learn as we helped grow this business together. Thanks to everyone in the Foraker family for your support and friendship, for the opportunity to be a part of one of the most dynamic and talented software development shops on the Front Range, and for all that you have taught me over the last few years. It has been an honor and a privilege to work with such fine folks. I will miss you all, and wish you all the very best for the future!

Posted: June 23rd, 2013 by Neal Enssle
Tags: ,
No Comments »

My management philosophy

Part 5 in a series on managing programmers

Here’s a list of some of the things about management that I expect from myself, and from people I work with and for:

I believe that 95% of all problems can be solved with better communication. Good communication is appropriately clear, comprehensive, timely, and frequent. Good communication adopts the right tone and is and channelled through the right media. Communication is often more about listening and asking than talking.
It is the responsibility of leadership to be honest and forthright in their dealings with people inside and outside of their organization. Leaders are able to share both good and bad news in constructive ways with peers, team members, and customers. Good leaders encourage people to be honest with them.
Believe in people. Actively demonstrate confidence in their abilities. Look them in the eye and openly affirm your trust, keeping any private doubts locked away. These are things that empower. Delegate actively but always with a commitment to help, to teach, and to learn. Tell people you have their back, and then be there when they need you. We gain trust from others when we actually do what we committed to doing.
Fear, uncertainty, doubt, and randomness are the enemies of productivity and happiness. Work to make sure expectations are clear. Strive to minimize surprises at all times. Timing is everything.
Stand up and take ownership of the situation. Generate solutions, not additional problems. Be willing to take the blame, and quick to admit mistakes. Do not make excuses.
Embrace servant leadership. Lead with humility, and be ego-free when searching for the best ideas and solutions. Do what needs to be done, and believe that it’s never not your job. Treat people with respect independent of their status or disagreement with you.
Expect the best from yourself and from the people you work with. Challenge yourself and others to deliver quality. Know, follow, and create new best practices. Identify root causes. Note that true mastery is intensely pragmatic, and avoids letting perfection become the enemy of good enough.
Always be learning. Always be improving. Always be seeking a new and different perspective. Admit what you don’t know, then go find out. Avoid stagnation, and embrace change even though it’s always hard.
I believe there are two sides to every story, and that people generally have a reason for doing what they do. Reserve judgment as long as possible, and avoid assigning blame before you have talked to everyone involved. Deliver bad news in private whenever possible. Work to build up relationships built on mutual respect and understanding, and prefer talking with someone to talking about someone. Never say anything you wouldn’t say to their face.
Laughter really is the best medicine, and also a fantastic way to forge a common bond. Humor is a tool that should be used very intentionally, always with compassion, and always with the goal of building up rather than tearing down. Humor can soften harder blows, and can delivery feedback with subtlety. And if you can’t at least act like you’re having fun then do not be there.
People expect leaders to act like leaders. Stand up on stage and play the role to the best of your ability (yes, everyone is always watching). It is your job to make (hard) decisions, so make the call, take the shot. Leaders understand that inspiration is better than motivation, and that people matter more than processes, systems, or things. Leaders radiate positivity and celebrate wins. Leaders are often friendly but rarely friends with those they lead. Parenting may be a useful mental model if you remember that good parents are always responsible, always making mistakes, always learning, always doubting themselves, always and deeply caring, and always willing to make sacrifices and put the needs of their family in front of their own desires.

This is definitely a work in progress, but it sums up a lot of what I think and feel are important.

Posted: May 11th, 2013 by Neal Enssle
Tags: , , ,
No Comments »

Life in interrupt mode

Part 4 in a series on managing programmers

When I was first thrust into management, I would come home at the end of almost every day frustrated at how little I had accomplished. You see, like most technical managers, I still tried to keep myself involved in the task of actually writing software. I was a “working manager”, and still a developer (“75%!”). On my daily to-do list I had code to write, diagrams to draw, and databases to query.

But I felt like I “never get anything done” because, dammit, now that I was “the boss” everyone kept interrupting me. I found that even on days when I only had two or three meetings scheduled I’d still end up spending most of my day in hallway chats, impromptu one-on-ones, emergency client meetings, and responding to about ten times as many emails and phone calls as I’d had to deal with before I became a manager.

It took me a good deal longer than it should have, but I’ve since made three key realizations:

1. A manager’s job is more about people than about code.

A manager’s primary job is to make sure his or her team members are operating at optimum efficiency. That means your job, as a manager, is to remove barriers and pave paths. Your job is to work with and through other people to accomplish goals. You are no longer a do-er. Your primary contribution to the organization is no longer embodied in the code you write, but rather in your performance as the “glue” between individuals, working on stage and behind the curtains to connect people and teams. You are a leader, and your job is to inspire, motivate, mentor, guide, and help other members of the team do the actual doing. Toward this end:

2. A manager’s job is to keep their team in “flow” as much as humanly possible.

In “Flow: The Psychology of Optimal Experience“, Mihaly Csikszentmihalyi’s defines a state of flow as “the mental state of operation in which a person performing an activity is fully immersed in a feeling of energized focus, full involvement, and enjoyment in the process of the activity. In essence, flow is characterized by complete absorption in what one does.” (Wikipedia). Most creative professionals, including programmers, do their best work when the are able to achieve a state of flow. This is the moment when as a programmer you’ve got 18 different variables, 7 competing business requirements, and the entire architecture of the system you’re building loaded into your brain as you work through a challenging implementation. It took most of the last hour for you to get yourself to the point where you’re in flow and able to make forward progress toward a solution, and all of that can get flushed down the toilet with one single interruption. Which is why:

3. Managers endure life in interrupt mode in an attempt to prevent their team from having to step out of flow.

You no longer get to spend as much time in quiet solitude, working for hours crafting a nearly-perfect solution on a single problem. Rather, you are supposed to be there to run interference and, yes, to run errands for your team. Your new role expects you to be able to juggle multiple balls, multiple projects, and multiple priorities. Which requires, at most times, multiple personalities. In one moment you’re the wise mentor, working with a junior developer to clean up some code or get a test to pass; the next moment you’re the project manager politician fighting to balance a half dozen emergency requests across only three developers or write three dozen user stories before noon; and minutes after that you’re playing the gadfly, prompting your fellow developers to reconsider potentially problematic architecture decisions. And all of this talking and walking and meeting is in selfless service to the goal of trying to keep the rest of your team in flow.

This life in interrupt mode is very hard to take, and is very likely one of the main reasons why many new technical managers bail out of the job. But it also makes for very interesting and exhausting days. Because after you get home and get the kids off to bed you still have your fair share of code to write, diagrams to draw, and databases to query…

Posted: April 25th, 2013 by Neal Enssle
Tags: , , , ,
No Comments »

How to quickly disable the HTML 5 cache manifest using Rails

I’m playing around a bit with the HTML 5 cache (here’s a good introduction to AppCache) for a web application I’m working on. Part of the fun is how to expire the cache when testing. In Google Chrome one can simply browse to:


But I wanted an even quicker way to see what happens when browsing to a page that has not been cached in the AppCache. And one quick way to do that is to load the page without a valid cache manifest. Like so:

<!DOCTYPE html>
<%- manifest = params[:manifest] == 'false' ? '' : '/cache.appcache' -%>
<html lang="en" manifest="<%= manifest %>">

So whenever I pass “?manifest=false” in the URL, it passes an empty string to the “manifest” parameter instead of the actual file name, and so therefore doesn’t load the cache manifest. It’s important to point out that this does not blow away the cache manifest file (that could be arranged, however, no?). The manifest file is there, undisturbed, until we call the page again without the “manifest=false” parameter.

Note that this would work with almost any server-side scripting language (e.g. PHP, ColdFusion, etc.). And yes, it’s a hack, but wrestling with the AppCache is enough of a challenge that I thought this trick might be worth sharing.

Posted: November 1st, 2012 by Neal Enssle
Tags: , , , ,
No Comments »

Rocky Mountain Ruby Conf 2011

The Foraker Labs team had a great time at this year’s Rocky Mountain Ruby Conference (#rockymtnruby). It was fantastic to see a full house at the Boulder Theatre for the two days of the conference, and we enjoyed hanging out with old friends from within the Boulder Ruby community, as well as getting a chance to meet a whole host of visitors from near and far.

Here’s a brief overview of some of our favorite talks.

Posted: September 27th, 2011 by Neal Enssle
Tags: , , ,
No Comments »

How to sort query results using a SELECT clause in the ORDER BY

The other day I needed to order a SQL query using by a value derived from a sub-query. Turns out it’s pretty straightforward:

FROM posts
ORDER BY (SELECT last_name FROM comments WHERE post_id = DESC;

The ORDER BY clause will use whatever’s returned from the subquery to order things.

Posted: May 23rd, 2011 by Neal Enssle
Tags: , , , ,
No Comments »

How to pick a random element from an Array

Here’s a nifty little patch to Ruby’s Array class to provide a method for picking an element at random:

class Array
  def random_pick
    self.sort_by { rand }.first

So then you can do things like this:

def what_is_your_favorite_color?
  colors = [ 'red', 'blue', 'green', 'yellow', 'purple', 'pink', 'black' ]

Please don’t ask my why I’m doing this. The answer has something to do with test data.

Posted: February 28th, 2011 by Neal Enssle
Tags: , , ,
1 Comment »

How to be successful as a web developer

…in 5 easy steps:

1. Stop complaining about the client.

2. Stop complaining about the project.

3. Stop complaining about the team.

4. Stop complaining about the technology.

5. Start solving problems.

Posted: November 22nd, 2010 by Neal Enssle
Tags: , , ,
1 Comment »

How to detect if a Rake task is being run with --trace

So occasionally I want to output a debugging message for a Rake task. That’s easy enough. But what if I only want to output that message if the Rake task is being run with the --trace option? It turns out the answer is to check the Rake.application.options.trace flag in your task to determine if the --trace argument has been passed in, like so:

desc "The answer to life, the universe, and everything"
task :answer do |t|
  puts "42"
  if Rake.application.options.trace
    puts "Task '#{}' is in --trace mode"

Note that you can also set Rake.application.options.trace = true in your Rake task if you always want to see the stack trace information.

Posted: November 12th, 2010 by Neal Enssle
Tags: , ,
No Comments »

comprar garcinia cambogia | free tarot reading | Observed that generic viagra rx trachoma may exist in one eye of an.