Tag: teams

  • What Makes a Good Team?

    What Makes a Good Team?

    Credit: Joe Groove

    No team is perfect, but I think it’s often kind of obvious when a team is bad – there’s usually a level of chaos or drama, a sense that they can’t be relied on or don’t really deliver the value that the organization needs. I think it’s also quite obvious when a team is good, mainly from the output of the team, but the underlying operating that goes into that tend to be less obvious.

    Practically, most teams are somewhere in the middle. Not terrible, but not as good as they could be either. Here’s my list of what I think makes a good team. If you think I’m missing anything please let me know in the comments or on your preferred social media.

    Clarity of purpose – people understand why the team exists.

    Defined work streams aligned with purpose – people understand what the team is doing (and why).

    Good team communication (openness, psychological safety) – communication is the foundation of collaboration.

    Connected, but not cliquey – the biggest predictor of work happiness is having a friend.

    Good delivery fundamentals – this is the team delivering its purpose, consistently and over time.

    • Work gets done and to agreed standards
    • Delivery is consistent medium term, not just short term sprints + burnout
    • Mistakes are a source of learning
    • Team is reliable <> people are reliable
    • Time is spent on higher value activities (complex tech designs > linting)

    Good people fundamentals – the necessary ongoing maintenance work for any team. Without good people fundamentals, management debt gets generated, which over time becomes corrosive.

    • Everyone has a good manager
    • Onboarding is predictable
    • Feedback loops are solid
      • Under-performers are addressed (up or out)
      • High performers get developed
    • Equity (in work allocation, advancement)

    Good process fundamentals – like the oil that keeps a team moving, process is the base level organization that facilitates team effectiveness.

    • All process has a purpose
    • Easy things are easy
    • Hard things are possible
    • Processes are fluid and evolving (continuous improvement mindset)

    The above items were the static needs of a team, if a team is going through a period of higher growth there is some additional complexity, such as:

    • More complex hiring (new roles)
    • More intense people development (stretch assignments)
    • Removing bottlenecks before they hit
    • Updating processes before they break
    • Balancing risk/reward, (stretch assignments, creative bridging of gaps)

    If you liked this, you may also like my book.

  • Where do you start when a team is broken?

    Where do you start when a team is broken?

    My latest in Quartz…

    One of my friends just took over a new team and found… far more of a situation than she was expecting. She faced a choice: commit to the turnaround, or switch to something that seems like a better bet.

    Of course, I advocated for the turnaround. Struggling teams are places of  opportunity, both for leaders and other team members, to demonstrate dramatic improvement and impact.

    But we shouldn’t gloss over the very real risk that the team will not improve and ultimately be disbanded, presenting a career risk for everyone involved. (Nor should we gloss over the fact that bias and inequity means certain portions of society are much more able to take career risks than others.)

    Turnarounds mean the hard work of change management, which is a daunting task. I previously wrote about the first questions to ask when your team is struggling, but what do you need to do even before that to answer the question: Should I take this on?

    Continue reading…

  • Creating the Productive Tension

    Creating the Productive Tension

    Credit: MaxPixel

    When I joined the mobile team at Automattic, we had one designer – Matt Miklic, who wrote about the explerience of leading that team. However one thing I was reminded of following some of the current discussions around product development is how we thought about and approached design at the centre of the team, and how we worked (and continue to work) to create a productive tension between design and development.

    Product engineering teams rely on design to function and deliver. What you see when design is not present (or not delivering) is engineering being reactive and short term focused, or rabbit holing on large technical infrastructure projects. This is a common problem, especially as design has become a bigger focus and design organizations try to balance the integration in product teams with creating a community across designers within an organization. The alternative is designers isolated, reporting to someone who doesn’t really understand their work – not great either.

    When design and development are both present we can move towards the productive tension of good decision making – the designer deeply understands and advocates for the user, the engineering lead understands the technical constraints. Together, they can agree a path forward that delivers the most user value over time, how best to test and iterate, what is required for V1 and what is required for “done”.

    This requires that design has a seat at the table – the team leadership table, but also in every project. The designer needs to be present, integrated, and listened to. It’s easy for engineers to outnumber and overwhelm, which can make it harder for design to speak up.

    But equally, there is no value to a perfectly designed thing that is never delivered (any more than there is to a unusable thing delivered very fast). The design has to be balanced with the technical work, the understanding of the components, the APIs that can mean seemingly small UI changes vary in time estimate between months and days. When I worked as an engineer on a deadline it was normal for me to go through the mocks with the designer, explain what was a component and what was not, offer alternatives and timeframes and let them decide what was shippable and what was an enhancement. It allowed us to deliver much faster, in a situation where we both understood – and agreed – on both what and why.

    Matt and I muddled our way through creating this on one team, based on our own gut feelings, good (and bad!) experiences and a few examples. Then we set off to deliberately recreate it on another team. This really cemented it for me as a straightforward and workable model, but also highlighted the need for three things: staffing, focus, and competence.

    Staffing: You can only take on the projects that you can staff, but if design is going to be this central to the team then design needs to be accepted as a limiting factor in what you can potentially take on. You can’t just allocate your projects and then divvy them up amongst designers and hope for the best – no-one delivers their best work when overloaded, and making design a bottleneck breaks trust, and leads back to the situation we started with – engineering working around them to deliver something (anything!). Navigating a really understaffed design team was an ongoing challenge for us, and heavily influenced what projects we could take on, and within those projects how we would approach things. If we couldn’t staff a designer at the start of a project (never ideal), what could engineering get ahead on? If we didn’t have enough designers for each projects what could we take on that did not require design?

    Focus: Changing the way of working always requires a lot of focus, changing that way within some real constraints (such as understaffing) meant that we had to remain super focused and deliberate on the end goal. This requires a lead who is willing to say no, and being willing to disappoint people short term in order to be able to deliver a better experience overall. However it also required some pragmatism and balance, citing a far off ideal that is clearly infeasible any time soon just makes people impatient. To mitigate things like that, Matt allocated one day a week to doing trash pickup, so that little things weren’t kept waiting on design forever, but could keep moving forward.

    Competence: This is not a statement on working with competent people in general (although like most people I much prefer that). But this model meant building leadership as a competence in designers, and user awareness as a competence in engineering. Both designers and engineers need to learn how to negotiate, and how to communicate pragmatically with one another.

    The thing to remember is that a strong delivery team is cross functional, in a way that may or may not be reflected on the org chart. However when your teams differ from your org chart, the responsibility for developing and coaching needs to be super clear, along with the lines of accountability. For example, whilst onboarding a developer is primarily the responsibility of the engineering lead, onboarding a designer is a responsibility shared between the design lead and the engineering lead; it’s important that they support each other in that, and that the new designer knows who to go to for what.

    So how do you create that productive tension? Some key points and milestones:

    • Get clear on the users your team serves – user research, data, insight from support all help here.
    • Define your team and design within it – make sure design has a leadership role.
    • Educate the engineers on the users – their goals, their problems. Build user empathy as a team competence.
    • Empower the designer as the user advocate.
    • Engineering needs to engage with design from the start, providing sensible information on what’s easy and what’s hard, and understanding the nature of early exploration – which needs to be nurtured, not shut down.
    • Make the space and relationships to have the conversations about goals and trade offs.
    • Integrate design into the process – engineering needs to keep design in the loop on progress, share builds, and shouldn’t make adjustments to the agreed design without discussion.
    • Ship together – it’s not just an engineering milestone, but an everyone milestone.
    • Involve design in post delivery analysis – what does the data say people are doing vs what we hoped? What do we need to adjust?

    Thanks to @MattMiklic, @Folletto, @lynneux and @skamille for their feedback and support.

  • The first two questions to ask when your team is struggling

    The first two questions to ask when your team is struggling

    Screen Shot 2018-10-02 at 07.50.36.png

    My second article in Quartz…

    I’ve never stepped into a leadership role without it quickly becoming clear why a new leader was needed. I think it’s normal for companies to hire new leaders when there are problems that need to be addressed. So I suspect that as the congratulations die down, it’s also normal to look at the set of problems that surround you and ask, “Where do I begin?” (also normal: “What have I done?!”). I suggest instead starting with these two questions:

    • How do I create clarity?
    • How do I create capacity?

    Continue reading…

    Thanks to @beaulebens whose questions and observation inspired this thinking and to @folletto for the helpful structural feedback.

  • Towards Productive Technical Discussions

    Towards Productive Technical Discussions

    Note: I wrote this post for an internal team blog, but thought it was worth sharing more widely.

    wool-2197757_1920.jpg
    Credit: Pixabay / congerdesign

    Part of getting to good code reviews is some up front discussion about trade-offs and implications for bigger architectural changes. I think of code review as when “my” code becomes “our” code – for architecture, those conversations need to start earlier. We all live with it, decisions have consequences beyond the project we are currently working on, and it has a huge impact on our ability to execute over time.

    Some things to think about when giving feedback:

    Ask questions. If it’s not clear to you 1) it’s probably not just you 2) it’s still worth clarifying.

    Think further out. How does the proposal affect things in 6 months? 12? We might choose a shorter term option, but we should make a mindful choice.

    Consider the effort vs the impact. I think this is a really important skill as an engineer or designer that I expect everyone on the team to have some sense of. We hire experienced people who we can trust to be autonomous, and I think this skill is pretty critical to that level of trust and autonomy.

    Don’t nitpick. Small details are distracting. Big picture feedback is more important. If something is a nitpick, clearly mark it as such – and then consider whether it’s worth nitpicking at all. When that nitpicking can be automated, let’s do that. It’s fine to be reminded by a script. It’s not a good use of anyone’s time to be reminded by another human.

    Style guides. It’s easy to have opinion on style, but consistency is more impactful than the details of it. The purpose of a style guide is to never discuss it again. Every other discussion should focus on the substance of what is being proposed, not style.

    We need to be less afraid to give people feedback in general. Technical feedback is a great place to start since 1) that is our focus 2) it is not personal. You can question and critique someone’s idea or proposal without attacking them as a person, and being able to have our ideas and proposals critiqued without taking it personally is important for any professional. We don’t have to agree with each other on everything in order to treat each other with consideration and respect.

     

    Some things to think about when asking for feedback:

    Put it in the right place. Small changes are best discussed in PRs. Bigger changes are for the internal blog (but as an OSS project should be in the README architecture document once decided).

    Be clear about the problem you’re addressing. This is really helpful context for people to understand where you’re coming from.

    Explain why it’s important. Make a case for the impact, and why now.

    Talk about what you’ve considered. What are the alternatives and their tradeoffs? Why do you think this is the best option?

    Think about the kind of feedback you want. What would be most helpful? What might other people have more knowledge of?

    Be clear on next steps. When do you need to make a decision? What do you expect to happen next? Who do you need to agree / help?

    Making Decisions

    The goal of these discussions is to define a path forward, and they should end with a specific decision which we then act on. Non-decision decisions* are a common dysfunction that I strongly prefer we avoid. Have some back and forth, switch to a call if necessary, but at the end of the thread there should be a decision and some next actions. Review the feedback, answer the questions, and then based on that, circle back, summarize, and state the decision.

    If the thread has been productive, and people feel heard, this might still feel scary but at this point we have all explained our point of view, and should be willing to accept the outcome.

    * Non-decision decisions: where a decision is made by not making a decision.

  • How Should We Define Success?

    This is part 5 of a series of blog posts based on a talk I prepared called Successfully Derailed Product. It’s about the ways in which we define and talk about “success” influence what – and how – we build. See part 1, part 2, part 3, part 4.

    What we’ve covered up to now is how the ways in which we define success don’t work, or break down when they come into contact with other people and their definitions of success. It’s okay to be despondent at this point – me too.

    One thing we haven’t talked much about until this point is company success. If we want to stay employed, we hope the company we work for will be successful. When a company does one thing, in a very focused way, company is like a superset of team. We can go through the same exercise.

    As companies get bigger, and do more things, the company becomes the context. The processes become more relevant to individuals and small teams than the mission.

    (which is why you need to be very careful what they are)

    “My first denied promotion taught me the wrong lesson. I thought I could keep doing the same work but package it to look good for the promotion committee. I should have done the opposite: figure out what the promotion committee wants, and do that work exclusively.

    I adopted a new strategy. Before starting any task, I asked myself whether it would help my case for promotion. If the answer was no, I didn’t do it.

    My quality bar for code dropped from, “Will we be able to maintain this for the next 5 years?” to, “Can this last until I’m promoted?” I didn’t file or fix any bugs unless they risked my project’s launch. I wriggled out of all responsibilities for maintenance work. I stopped volunteering for campus recruiting events. I went from conducting one or two interviews per week to zero.”

    ~Michael Lynch, Why I Quit Google to Work for Myself

    I’m sympathetic to this guy’s conclusions – the post is a story of how someone wanted to be a diligent engineer and a good teammate, but the promotion system, and their personal desire for promotion (and recognition!) meant what they personally felt incentivized to do made them a bad teammate. You don’t want to work with that person, and you don’t want to be that person. But this is what the system told them “success” looked like.

    Running engineering teams like this definitely impacts product – which impacts users too. For internal users whose service becomes unreliable or unmaintained once someone gets promoted (or because it won’t help someone get promoted), or external users who live with things that aren’t great, because improving or fixing them is not promotion worthy – so no-one wants to do it.

    The end of this story, by the way, is that he figured out how to play the system, got great review scores… but his teams kept getting re-organized which made promotion impossible – and that wasn’t a gameable system. So he quit.

    One of the reason why I was looking to see how many articles mentioned users in my research around teams is that studies show that people are more motivated when they see how their work impacts real people. Fundraisers for scholarship donations were more motivated when they had contact with scholarship recipients. Lifeguards were more vigilant after reading studies about people whose lives had been saved by lifeguards. When cooks see who will be eating their food, they feel more motivated and work harder.

    Are we doing that in development teams? Well if we are, we don’t seem to be talking about it that much. I ask everyone I interview if they have any experience with user testing, and the overwhelming majority say no. But – those who have that experience talk about how impactful it has been on them.

    So this is really not about how teams should define success – but about how we can align team success with user success. This changes our definition of what success is, and it’s also good for motivation.

    But – we have to be careful that we actually do understand what users consider to be success. I used to work on a carpooling app, and we talked about how people wanted a way to organize their car pools and exchange money more easily. But I used to read every support ticket, and the what I ended up suspecting was that really what people wanted to do was track their carpooling in order to qualify for company eco incentives. Which… sounds a lot less like a viable business model. So you know… I don’t work there anymore, and neither does anyone else.

    One thing we do on my current team, is a quarterly “empathy challenge” where we attempt to connect more to how people use the WordPress apps – there are options, like joining a call with a new customer, or running a user test, or blogging ourselves from a mobile device. We collect case studies of people who are regular users of the apps and ask them about their website, what are they trying to do with it, how do they use the app. Everyone on the team starts with three weeks in support and spends a week each year doing support – and it’s important to listen to user pain and frustration. But we’re trying to balance that by also listening to people who are happy. It’s important that we understand what’s broken, but it’s also important we understand how we’re helping people reach their goals. It’s also much more uplifting. And it reminds us that whatever we ship is measured not in lines of code, or how technically interesting or challenging it was… but how useful real people find it.

    Because despite what the aliens may have concluded – we don’t run teams to run teams. We run teams to do something.

    Keeping this mindset also changes the way that we talk about our work and focuses on impact rather than the details of what. It doesn’t necessarily change what we do – but it does communicate the why more effectively. And it does make the “finish” line clearer – because that’s around the impact – something that we can share as a “this is a new thing for you”. If we don’t feel proud of talking about what we’re doing in that way, then maybe it’s not yet finished, or maybe it’s not worth doing at all.

    As a result, we rebranded “Networking refactor” to Full Jetpack Support,  “New Editor” -was rebranded to talk about accessibility and performance, and being a building block for Gutenberg. We rebanded “Async” to be about not waiting for media to upload when you’re ready to publish. Finally we rebranded “Bug fixes and improvements” to #NoMoreBrokenWindows – making it a point about how we wanted to improve the polish and overall experience.

    These things can seem silly, or manipulative, like they don’t result in more being done as a team, but regardless of what is objectively true – and how would we measure it anyway – tying our success to user success gave us a sense of meaning, which I think translated to momentum and focus. Our support people tell us they spend less time helping people with basic things that shouldn’t confuse them, and out app store ratings have crept upwards.

    Now we’ve aligned the team with our users, what about individuals?

    Maybe now you’ve gathered, I’m not really big on “should”, so this is really: how can you create success for people in a way that aligns with your team? Because even though individual success is personal, people respond to the expectations – and incentives – we create for them and those can work against what’s best for the team and the product if we’re not careful.

    What’s next? How we can create alignment.

     

  • How Do Teams Define Success?

    How Do Teams Define Success?

    This is part 3 of a series of blog posts based on a talk I prepared called Successfully Derailed Product. It’s about the ways in which we define and talk about “success” influence what – and how – we build. See part 1, part 2.

    Taking a step back from individual success, I wanted to understand was an industry we talk about building teams. What is the team working towards? What motivates them? What bonds them? What makes them proud?

    I turned to a resource called Software Leads Weekly. It’s a newsletter that was one of the first things I was pointed towards when I became a manager, and it’s read by around ~18K people a week. I figured it would be a reasonable example of how we talk about technical leadership. I went through every issue this year, 13 issues with 130 articles and categorized every article in a spreadsheet. Blog posts made a bit over 50%, and tweets a bit under 40% (I shouldn’t tell my boss this, he’s pretty into blogging), with the rest a mix of media articles, video etc.

    To try and quantify the bias here, whilst I was at it checked the gender breakdown of things included. 15.4% of included articles where by women. Now, gender is not binary, and not the only measure of diversity. BUT – it’s easiest to quantify, and necessary but not sufficient. I.e. if something is genuinely diverse, it will have good representation of women. If something is representative of women, it can still be poor at representing other axes of diversity like race or ability. Now for those of you who think 15% is OK, because it’s about tech, note that not all the articles are from tech, and so there’s plenty of possibility to do better than the poor standards of this industry. But that is not taken.

    I read a good amount about management, and running teams, and sometimes I wonder if an alien was studying this, like the way the alien in Hitchhiker’s Guide called himself Ford (because he thought cars ruled the earth), what would they think development teams do?

    So finally, I have my answer. And it’s pretty much: they might reasonably think we run teams to run teams, as some kind of cultural ritual.

    The most popular categories are team operations – which was a broad category included things like process, job roles etc, and individual effectiveness which was narrower – personal productivity strategies – time management, decision making, etc. Less than 30% of articles had the word “user” or “customer” in them, but only 2 could really be defined as being about users and what the software we build is for.

    I rounded out this biased research with some more biased research on Twitter.

    I got some interesting responses. But I’d also love to know what you think. (Leave your answer in the comments or tweet at me).


    Note – much less popular, and far fewer responses. I wonder why that is? Do people have less clarity there? Are they less willing to share it?

    Capture d’écran 2018-04-03 à 11.49.35.png

    There are two themes worth highlighting here. One is clarity, the other is psychological safety. Clarity around what the team is doing, and needs to do. Psychological safety is about the team feeling good about getting there together.

    Capture d’écran 2018-04-03 à 11.49.41.png

    I like the idea that “a successful team cares”. One thing I would highlight here is how quickly “what does a successful team look like” becomes “things managers should and should not do”.

    Like… optimizing for playing video games. I have some feelings about this…

    Capture d’écran 2018-03-23 à 10.27.37.png

    I’m not sure what to take from this research. It’s hard to see the relationship between what individuals are seeking out and what teams are. At best, we’re talking about teams as an environment for individual work, rather than the way in which we work together on something bigger.

    Maybe that we’re more comfortable talking about video games and individual effectiveness than the bigger differentials of effective teams? Are these the things that we just don’t want to talk about in public? I run a slack for engineering managers and the topic discussed there are very different.

    I wonder if part of this is the challenge of generalising when teams are made different not just by the people in them, but in the circumstances they operate in, and the harder things get the more personal things become. When we distill to a blogpost, by necessity we leave much of the complexity out of it. So it’s a lot safer to write about how to bring in Kanban, than is it to talk about how to manage up. It’s much easier to talk about how to hire than how to fire – and hopefully we do more of the former, anyway. It’s more enticing to talk about the CI stack than the slow grind and many failures towards achieving product market fit.

    But ultimately I think any experienced manager will tell you the harder topics make the biggest difference to the a team that executes on meaningful work, than a disconnected non-team that does not execute at all.

    What’s next? How users think about success.

  • Running an Effective Mobile Team, Part 5: Automating Things

    Running an Effective Mobile Team, Part 5: Automating Things

    Robot-clip-art-book-covers-feJCV3-clipart.png
    Credit: Wikimedia

    Let’s talk about automation. This seems like an out of place thing in this series. Predictable! Prioritized! Connected! Accountable! These are all fuzzy people things. Automated sounds like… more fun? Like Proper Developer Work?

    Automation is like documentation, but developers might actually write it.

    Without automation:

    • It’s easy to have random esoteric things that few people know how to do.
    • It’s harder for others to take over process like builds.
    • A lot of time is spent on manual processes that are straightforward to reproduce (e.g. basic QA).
      • Either bugs are missed because this is inconsistent.
      • …or at takes time that could be better used elsewhere – e.g. more complex scenario testing for QA professionals.

    What can we automate?

    Automate builds. Seriously. If you commit to predictable releases, you will end up investing in automation to maintain that process – otherwise it’s too painful. This includes things like scripting translations etc. There’s a chicken and egg problem there, where push back on regular releases can be lack of automation. But I’ve found there are few things more motivating for motivation than regular releases.

    Write tests. I can’t believe I’m still trying to convince people tests are important in 2017. One of my current work hobbies is noticing GitHub threads with clear testing instructions for reviewers and commenting “this would make a good automated test”. Other common GitHub comments from me: “can you add some tests, please?” And “I like these tests.”

    Add linting. I believe in Styleguides. The main purpose of styleguides is this: we have a style guide so that we never need to discuss it again. I once witnessed a centithread argument about whether it should be var == thing or thing == var. Who has time for that kind of nonsense?! Have a style guide, automate it so that Android Studio or XCode apply it automatically, and your code review system shows any deviations – so that your reviewers don’t have to. Code review – done well – is a great collaboration tool. In a dysfunctional environment, it’s the first place conflict will show up. One positive (but insufficient) step towards productive code review is eliminating nonsense arguments about spacing etc.

    Tooling on mobile is still behind, but it’s getting better. Things can be a bit more painful to setup, but if you make the time it pays off.

    Part of it is having that time. When everything is so frantic, there’s no time to automate painful things to make them less painful.

    The anti-pattern of automation is over automation. I’m sure you’ve worked with people – or been that person – who crafts some elaborate system that only they can use to address some minor problem (that only they can see).

    Pragmatically with automation, taking the most painful or tedious, hard to socialise parts and making things better is the place to start.

    Read the final part, on accountability.

  • Upcoming Talk on Effective Mobile Engineering Teams

    Upcoming Talk on Effective Mobile Engineering Teams

    devices

    I’m working on a talk about running effective mobile engineering teams – I’d love to know what questions you have about this, what you worry about when it comes to mobile teams in your organization, and what you’ve found most helpful to communicate about them. Comments or email or DMs on Twitter welcome!

    Title: YOLO Releases Considered Harmful – Running An Effective Mobile Engineering Team

    Organisations often worry about their mobile teams. Sometimes they are a bit separate. There’s often this inexplicable hostility to mentions of “React Native”. Why do bug fixes take so long to get to production, and what are all these certificates for, anyway?

    In this talk we’ll cover the realities of shipping compiled code, the woes of the app stores, and the infrastructure challenges we haven’t figured out yet. You’ll leave with a better understanding of the realities your mobile teams may be struggling with, and some strategies for how to help them – and your organisation – build an effective mobile team that ships regularly. And yes, you’ll finally understand the React Native argument, too.