Scenarios that make you scarce
Software development productivity is the ratio of desirable high-quality software to money spent. With this meaning, productivity is aligned with quality and effectiveness: it only counts creating “the right software” and encompasses creating “the software right”. Productivity is more important than efficiency (the lack of waste), as occasionally a bit of inefficiency pays off.
In the quest for some combination of these values, project management methodologies or practitioners generally assume that members of a team have approximately similar scarcity/availability/cost. But sometimes, you may find yourself more scarce than a group you are working with:
- You are leading at a high “fan-out” – one person leading a team of many.
- You are leading a team expected (for good reasons or bad) to expand or turn over significantly.
- You are much more senior than the rest of your team.
- You are in an expensive city or country, other team members are in a less expensive locale.
- You are a “hired gun” consultant, brought in at great cost, expected to “move the needle”.
- You are a professional developer responsible for mentoring, teaching, and getting results from a group of interns.
- You have a communication advantage with the customers of a product or project; perhaps you speak the customer’s language more fluently than others on your team.
- You are the only team member with extensive and relevant experience to the problem at hand.
In a competitive world, productivity wins. These techniques can help optimize productivity to get the greatest possible results when working at a scarcity gradient. Such a gradient is often accompanied by variable or unpredictable availability of some or all team members; and many of these techniques optimize results for both constraints.
Every idea here comes from experiences at Oasis Digital, on those projects which had the highest efficiency and effectiveness.
As a scarce developer:
- Act as a leader, as an expert, as a coach, and as a pseudo-customer.
- Facilitate, support, and guide less scarce developers.
- Work in a scalable way; each unit of your work enables many units of others’ work.
- Scale across space (multiple other developers) and time (present and future developers).
- Each hour of your work should enable N hours of others’ work.
Avoid 1-1 email; avoid 1-1 IM; avoid 1-1 Skype or phone. Avoiding writing text for only one person; avoid creating a screen video useful only once for one person. Instead, spend as much of your communication effort as possible, communicating to a group of current and future developers.
Avoiding one-on-one can be very challenging. Depending on the culture of an organization or community, you might find that the less scarce developers strongly prefer one-on-one communication. You must resist this to work efficiently.
Generally skip one-on-one communication unless it is for a personal or HR matter… but for those critical conversations, spend the time you’ve saved up and speak, live. In-person or (for remote) with video+audio conferencing.
It is key to remember the “mostly” part. Have occasional one-on-one meetings with each team member. Because of the scarcity factor, do so much less often than the typical recommendation of once per week per team member.
When you write, prefer writing in documents with ongoing usefulness. Prefer writing in shared documents, not in email. Prefer writing text anyone could read, not notes made only for yourself. Text written in this way is useful for many developers, both at the present and in the future. Name the documents well – not just “Notes” or other nondescript name. If you type slowly, consider voice dictation. (Reasonably good and immediately available voice dictation is available in Google Docs!)
Record screen videos
Screen videos are are especially useful to explain to many developers, across space and time, how something works. They are also very fast to produce.
Screen videos made for fellow developers have a lower quality bar than those made for customers. It is still important to have clear audio (neither too loud nor too quiet, and not full of background/fan noise), but the pace and flow can be somewhat rough, and a “first cut” is almost always good enough. Still, always name screen videos well – make sure people can find them with a reasonable search, and can understand the topic by reading the name.
Small, topical pieces
Resist the urge to ramble for 30 minutes explaining everything in one video, or to spend 4 hours writing up everything in one document. Divide your effort into separate topics, and make a separate document or video for each. Pay attention to the names, and name each piece in a way that reflects the topics in it.
By doing this, the material you make is much more likely to be useful beyond the need at hand. For example, an explanation of a database schema should not be in the same video/doc as an explanation of a report that uses the schema; if is, then most likely a developer working on something other than reports, would not watch/read it. By splitting that to two assets, each can be reused independently.
Minimize the need for schedule synchronization – either work entirely asynchronously, or with perhaps one set meeting time per day. To maximize use of your scarce availability, decline requests to add more meetings or to set meetings for specific topics. Instead meet on a regular schedule and cover whatever topics are most beneficial to keep the group moving, each time.
Even though they are called meetings, don’t just meet. Work together, as a group, on the critical issues of the day. This is the most powerful mechanism to get a team in sync and pulling together.
Make room for social time
Whether your meetings are in-person or online, you are scarce and have limited availability… but meetings don’t need you the whole time. Leave meeting when you have to, and encourage the rest of the team to keep talking and working afterward.
It is unfeasible to ensure every relevant person is at each meeting. Specifically, some relevant people may not even be on the team yet, or maybe on vacation, or maybe unavailable for random reasons.
Therefore many development sessions and meetings should be recorded. This is typically inexpensive and easy to do with modern technology. The recordings can then land in a suitable place for developers who missed the meeting a need to keep up to review. Many will find they can do so in much less time than the meeting originally took.
Fast answers to small questions
Developers who are first learning about a project (or a part of a project they haven’t touched before) are prone to get “stuck”. It is thus helpful to answer small questions fast, if you are available to do so without major disruption.
Keep the “ball rolling”. Respond quickly, keep things moving. This can be tough to get used to, for anyone who has mostly worked alone in the past. Be careful to balance between good responsiveness and your own focus. For example, you might work steadily on their own direct tasks and pause once per hour to “come up for air” and respond to any pending quick needs.
Delegate this quick answering process as much as possible.
Batch larger questions and discussion
On the other hand, resist the urge to answer a larger question right away. You might accidentally:
Write a detailed explanation in email or IM, where it will get lost.
Write an explanation as a 1-1 answer to one person, where it won’t benefit anyone else.
Write an explanation where a screen video would have been better.
Combine an explanation of many parts of a system, making it not-very-reusable.
Instead, attack larger questions en masse, at the next meeting already scheduled for a convenient time.
Here is a rubric to route various sizes of questions and issues:
|How to Handle
|Answer or do immediately
|Batch up, prioritize, execute every day
|Break up, analyze, find ways to make bits of progress to allow others to move forward; prioritize to attack big things with enough intensity to complete them.
Delegate most of the small or easy questions. After you have answered or explained a certain area once, expect and enable new or junior team members to first get help from the less junior team members before seeking your scarce availability.
Delegate in the right direction
There is a surprising tendency for junior developers on a team to delegate work “upward”. Respectfully decline. Only for narrow reasons (such as requiring access to sensitive systems or data) should a task be delegated upward, toward a person in scarce supply. Most of them time, the real need is for more knowledge transfer, guidance, or key decisions – so do that, but don’t let actual work be delegated upward.
Aggregate, stochastic project management
Take an aggregate, stochastic approach to project management. Don’t attempt to micro-manage; don’t worry much about who works on what, when. Instead:
- Periodically write/groom a set of items that ready be done. These items should have enough explanation that a developer can begin work. This is the to-do bucket.
- Developers can grab items from the to-do bucket and work on them.
- No developer “owns” an item, or reserves it – if a task isn’t getting done, someone else can grab it and do it.
- Sort items between the to-do bucket and backlog.
- Work ahead: elaborate on items that will be worked on soon, don’t wait and make anyone “pull” the elaboration from you.
- Depending on the reason for the scarcity gradient (if it is based on a globally distributed team), there might be no common “weekend” across a team, no common working hours, no single idea of day and night, no common holiday schedule, and wildly unpredictable availability for each developer. Accept this.
- Embrace chaos, and work in a way that relies on the aggregate productivity. Let it all average out over time.
Place two bets
This is an extreme technique, suitable only for those able to think abstractly in terms of bets rather than concretely in terms of estimates, commitments, and dates. If the scarcity gradient is sufficient, and a piece of work is vital, consider placing two bets instead of one.
To place two bets, assign two different team members, or even two subteams, to take on the same work in parallel. If either one succeeds, work can be merged/shipped in your project wins. The only way to fail is for both independent efforts to fail.
This idea most sharply separates the ideas of productivity and efficiency. Sometimes the most productive thing is to intentionally be inefficient, to intentionally create a bit of waste, if the scarcity gradient is sufficient that the benefit is high and the waste is bearable.
Most agile processes have a notion of a retrospective meeting from time to time to discuss what is working, and what areas are struggle.
Don’t skip these just because your time is scarce. Make time to do retrospectives, and in particular you may be called on to explain why things are done a certain way. Don’t be shy, be willing to say forthrightly: we are doing X instead of Y because my scarce availability makes this the most productive overall solution.
For the whole team to work efficiently, the least scarce developers must be able to operate their computers and development tooling effectively with little assistance. Assistance would require 1-on-1 help, which isn’t workable as explained earlier.
Therefore, do not provide one-on-one assistance for project set up. Instead, create or update documents about how to perform project set up. New developers join, receive the documents, and work on their project set up. If developers have difficulties or questions for things not covered in the documents, bring up the document and edit it together live to answer the person’s question. Don’t answer their questions by providing extra info that doesn’t land in the document.
The project set up process can also verify that a hiring or project assignment process has produced workable results. Developers well-qualified to work on a project should be able to perform project set up without handholding. When you are on the scarce side of the project, keep this in mind; you can demonstrate your suitability for a project by working hard, getting through project set up, asking the questions that have to be asked, but figuring out most of it yourself.
Daily / Continuous Process
Combine many of the techniques above into a daily (or really, continuous) process to get the most overall value out of your’s relatively scarce availability:
- Review any new commits. Review them in a time efficient way; quick comments can be typed, detailed reviews are best done via video or as part of an en-masse live discussion.
- Fix any source control problems. If someone did something wrong (like pushing unreviewed or incomplete work to master), fix this right away, do not let it sit.
- Merge anything that is ready to be merged – so every open branch/commit should be either merged, or have at least some comment pointing its developer in the right direction.
- Look over the current milestone.
- Notice anything not up to date – update it, or have the person who did the work update it. It should be possible for an observer to know the status of a project by looking at the contents of the issue tracker.
- Look over any “triage” items and place them in a milestone.
- Check that the current in-process and to-do work is still a reasonable set of priorities, adjust if needed.
Chat / Email
- Discuss project matters in batched meetings or chat, rather than in painful, expensive, tedious email threads. If it’s too big for chat, it probably should be discussed in the next regular meeting.
- Look for opportunities to share the load of this answering; if one team member could have answered another’s questions, remind them to do so.
- Answer small questions quickly. Letting them sit greatly slows down a project. At the same time, many questions should be pushed out of email.
- If someone in email triggers a need for longer term work, it should probably be in the issue tracker.
- If technical discussions wander in to direct email, move them immediately back to shared discussion.
- Look past the immediate questions (which can be poorly written, especially with developers who don’t know a lot about a project yet) and answer the underlying questions.
- If some information appears in chat or email that should be in a document, copy and paste it there, or delegate someone to do so.
Transparency builds trust
The common theme running through most of the advice here is to bias strongly toward transparency. Team meetings, where you can see each other, and everyone’s work is in the open. Issue trackers visible to everyone, where everyone can see who has grabbed what work, and what they have done so far. Code review during group working sessions, where things that need improvement are candidly discussed. Nearly all communication dragged away from 1-on-1 chat email etc. and instead in the open.
This transparency builds trust, much more rapidly than would be expected without those practices. This way of working maximizes productivity not only toward producing working software, but also toward improving candid human relationships.
That’s enough words for today’s summary. Some of these topics warrant more elaboration; stay tuned.