What if your team could take on more work
with less active supervision from you?
Your team is bright and engaged, but requires active supervision from you to keep the ball rolling.
What if they could reach that next level that requires less work from you? what would that free you to do?
To achieve autonomy, developers must be skilled in four key areas:
What if your team could have more autonomy?
Your team believes in your company vision, is familiar with the codebase and its history, and has a process that works to get code shipped. They throw themselves into shipping, but often find themselves revisiting and redoing recent work that is incompatible with current work needs.
If only they had more technical mentorship than you have time to give.
Hiring senior developers is hard and takes a long time, and each one takes time to ramp up. During that time, they’re not only learning about your tech stack, they’re also learning how to work with the existing team, and what’s important to your product.
If only you could grow your less-experienced devs into senior developers, you’d have senior devs with the necessary context to be aligned with your goals.
Staff augmentation is both expensive, and lossy: when your contractor leaves, domain knowledge leaves with them.
Our technical mentorship service increases your ability to deliver, while knocking down knowledge silos and leveling up your team.
We don’t add to your ability to deliver. We multiply your ability to deliver.
What would it look like if your team were more autonomous?
Reduced churn and cycle time in stories from start to shipped
Fewer false starts. More developed understanding of product and business goals and closer understanding of the end user, combined with understanding that completed stories are what deliver value to the end user, get stories shipped.
Less time spent on less important work
More developed understanding of product and business goals mean picking the right places to aim for perfection, and the right places to aim for “good enough”.
Reduced technical debt
Technical autonomy means not just delivering a solution, but delivering a solution that doesn’t increase the brittleness of the codebase, and can be easily built upon.
Predictable bug aftermath
Better understanding of the software delivery process of the whole, combined with closer understanding of the effects of bugs on the end user, lead to the correct sense of urgency and ability to act on said urgency.
Developers know what to do next
More developed understanding of product and business goals, combined with closer understanding of the end user’s needs, mean developers know what to tackle in the absence of direction. Combining this with thinking ahead means developers know when to ask for more direction.
What are the components of autonomy?
We provide technical mentorship for the members of your team. We work with you and your team to increase your team’s autonomy, enabling them to grow and learn to take on more than they do today. We do this through a mix of pair programming and technical coaching, and adapt our strategies to suit your needs and the needs of your team.
When a developer has product familiarity autonomy, work tends to more closely resemble what’s important to the end user. They’re able to make tradeoff decisions because they have the context to know what will be valuable to your customer. Product familiarity gives a developer the insight to know whether being a few pixels off from the spec is or isn’t a big deal.
When we work with your developers, we teach them what questions to ask, and at what points in the development process, so that your developers can take advantage of their product familiarity – or find areas in which they must learn more.
When a developer has project management autonomy, work rates tend to flow relatively smoothly. Developers with this skill are able to anticipate and account for upcoming changes, whether it’s wrapping up a project or navigating unexpected blockers. Related skills include estimating time until completion, planning for coordination and research time before starting a new project phase, and knowing when to stop and break up a large feature into smaller pieces.
When a developer has collaboration autonomy, work completion tends to happen more predictably. Developers with this skill get their work accepted and into production sooner and without fanfare over the little bumps that may arise. Related skills include building alignment around contentious code changes, and timing merges so that QA has adequate time to test in staging.
We tend to think the most about, and value and assess, whether a developer has technical expertise autonomy. Developers with this skill are able to create technical solutions to presented problems, and adapt their solutions to complement both existing code and existing ecosystems. These solutions are compatible across required platforms, and work with existing dependencies. Solutions are able to easily support future changes.
Our Technical Mentorship service was heavily informed by a discussion with Marco Rogers.
We are very grateful to Marco for having described to us his ideas around developer autonomy, and for his feedback and validation as we created this service. Thank you, Marco!.
Ready for your team to become more autonomous? Let’s talk about how we can provide the technical mentorship that will help.