In my posts, I keep returning to the idea that the quality of our work is the only real way to build a good résumé and a strong calling card.
Although quality is an overly open-to-interpretation concept, in software it means that the delivered system or application works according to the client’s requirements and, of course, has no defects, is easy to maintain, can evolve, and so on. This seems obvious to me, although it’s not always taken into account in a developer’s day-to-day work.
However, the relationship between managing a software project and its final outcome isn’t always clear. In my opinion, management is not only important but decisive.
Software development isn’t just sitting down at a computer and having fun writing lines of code (well, it is that too, but my point is that it isn’t only that). When we have to deliver something by a particular date, we need to plan. When we work as a team, tasks have to be distributed coherently—in other words, the workload has to be managed. When laying the foundations for a new system, we have to make design decisions. And before all that, we have to gather, interpret, and translate into the developer’s language the specifications of a client who sometimes isn’t entirely sure what they want or need.
All of these points are just the tip of the iceberg, and every one of them is related to managing a software project—not to mention the responsibility that comes with it, since certain bad decisions can have catastrophic effects.
Naively, some people think managing means telling other people what to do and giving orders, then sitting back comfortably and waiting for everything to get done by itself. With that mindset, a software project’s failure is all but guaranteed.
Every project has its own particularities, and software projects have their own unique nature. In general, when someone faces project management for the first time, they don’t have a clear idea of what’s expected of them.
You learn through a great deal of trial and error (and sometimes those errors come at a high price). In my opinion, some of the essential skills a good software project manager needs are:
- Knowing how to prioritize the functionality that needs to be implemented at each point.
- Maintaining a coherent team by understanding each member’s weaknesses and strongest skills.
- Developing each team member’s abilities by applying enough pressure (without overwhelming them) to make a goal motivating.
- Creating a plan early enough to share it with the team.
- Never, absolutely never, breaking that plan (except on very rare occasions and for compelling reasons). Developers should always know which tasks they’re expected to do over a given period.
- Maintaining enough peace to work so developers can concentrate as well as possible. Sometimes this means standing up to a difficult client or even arguing with your own boss (the manager’s boss, I mean). At times, it also means not sharing anxieties or insecurities related to your own responsibilities as a manager, especially when they involve other company issues that the developers you lead may not understand.
- Keeping the client in check: making sure they don’t constantly change their mind and that any changes to the specification stay within budget, if you’re also managing the project at that level.
- Making sure the chosen tools and defined workflows are being used.
- Ensuring developers work under the best possible conditions: good equipment, appropriate training, and so on.
- Making sure the chosen development methodology is followed.
And a very long list of other things…
When a software project fails, the only person responsible is its manager. That’s it. Very few things truly come out of nowhere, and part of a software project manager’s responsibility is to manage risks: missed commitments, the quality of what’s delivered, and so on. If things do go wrong, the manager needs the courage to acknowledge mistakes, learn from them, and take responsibility. It’s not as if anyone’s going to crucify you; and if we’re smart in moments like that, we’ll learn a great deal from the mistakes we’ve made.
Unfortunately, there are many cases where the only way to advance your career is to get a management position for which you may not have the right skills.
Sometimes a management position (I have to say, I really dislike that phrase) is confused with sitting in a chair and having people do whatever you say. In reality, it’s nothing like that:
A manager’s responsibility is to manage technical, human, and training resources, among others, so that a product is delivered properly. It has nothing to do with being respected through medieval authoritarianism. It’s about earning enough authority for your decisions to be respected because you’ve demonstrated your experience and good judgment, as well as your willingness to own your mistakes (instead of blaming someone else, which is unfortunately very common).
Many software projects end in wonderful success thanks to the skill of the developers on the team, to whom an incompetent manager has delegated much of their responsibility. When that happens, I advise those developers to look for another boss or even move to another company, since they’re probably being paid much less than their manager, boss, coordinator, or whatever title they have. It’s unfair, but it happens every day in all kinds of companies.
Just as we look for a particular kind of company to work for, why not also seek out a creative environment with competent people who can help us grow even further in our careers? Are you surrounded by people you criticize, have to work with, consider incompetent, and feel contribute nothing except some giggling and joking over coffee? Take note: you’re wasting your time.
If you’re a developer who wants to manage software projects, try to work with a good manager who can pass on their experience, read books on the subject, and make it clear that you’re ready to take on new responsibilities. But be careful: don’t just say it—show it through the quality of your day-to-day work.
A project manager is always learning (anyone who thinks they know everything will be out of the market in a few years), and the developers they work with should also be able to learn as much as possible from them to become better at their profession.
If we work as freelancers, almost everything above still applies, since we’ll be managing our own work and, at the same time, developing a project that also needs to be carried out in an orderly way and with quality.