devopsy.kinsta.cloud

Tag: developer teams

  • DevOps Flow: Accelerating Velocity With Software Factory Best Practices

    DevOps Flow: Accelerating Velocity With Software Factory Best Practices

    In the cloud era, senior executives are investing in key capabilities like DevOps with the expectation this will accelerate innovation and bring new digital products to market faster. To deliver on these goals, enterprise organizations seek to deploy high-quality code faster and more frequently, but they face a organizational, process and technology complexity that can hinder this objective, slowing throughput and incurring high error rates. Often when DevOps is discussed, the focus is concentrated on the technology layer, particularly the latest tools like Kubernetes, and also on the productivity of each individual developer.

    However, for many organizations, the main challenges will be with team practices and organizational models.

    Writing for devopsy.kinsta.cloud, Mike Vizard highlighted the reality of DevOps uptake; that most adoption issues are related to organizational challenges, not technology. The top two barriers to adoption are slow processes and speed of adaptation (29%) followed by budget and funding (21%). Only 18% identified technology limitations as an issue.

    As Mike writes, it is the broader organizational transformation that is more challenging. ‘Addressing bottlenecks’ might be a function of confronting the situation of a department manager who zealously guards their turf and acts politically to resist any changes required.

    Implementing DevOps for one team is a relatively straightforward exercise, but for enterprise organizations, they face a much larger magnitude of complexity, as they typically have multiple teams spanning multiple geographies and suppliers with hundreds of developers all contributing to the same software development process.

    Therefore, a DevOps methodology that also addresses the organizational level is required, one that maps processes end-to-end and identifies the improvements needed to speed production across this entire life cycle.

    Software Factories

    Transformation leaders are turning to a ‘digital factory‘ approach to streamline this complexity into a production line model that yields consistently high throughput and quality using Lean principles derived from the manufacturing world.

    McKinsey explored the dynamics and successes of the digital factory model, a new approach to organizing digital teams. This model involves a self-organizing structure rather than rigid departmental hierarchies, and they described the KPI improvements the digital factory enables: “We see reductions in management overhead of 50% for technology teams in the digital factory, 70% in the number of business analysts needed to write technology requirements, and, as test automation becomes the norm, a drop of 90% in the number of testers. Finally, we see top engineering talent performing at eight times the level of their peers, as measured with metrics such as code commits.”

    In short, McKinsey described a development team that improves quality and finds efficiencies as a direct by-product of one that leverages the latest tools and team methods to produce better digital products faster. The concept of a ‘software factory’ is a very powerful metaphor because much of the insights are drawn literally from the world of manufacturing, where over many decades they have perfected the science of optimizing the efficiency of a production line.

    To close the loop and map these development improvements to business value, management can leverage organizational performance practices, notably Six Sigma and the theory of constraints, to define their ‘DevOps algorithms,’ a systematic formula for quantifying and improving the rate of software development throughput.

    DevOps Flow

    DevOps Flow is a methodology for implementing high-performance, cloud-centric software development based on science developed by pioneers like Toyota to optimize factory lines and apply this to software engineering.

    Organizations need the ability to measure the entire system end-to-end to understand how value flows and where it is constrained and, most importantly, to correlate those metrics with desired business outcomes. This approach allows for continuous optimization in the pursuit of delivering greater and greater value to the organization faster.

    It can be applied to speed the deployment of new software releases, notably identifying and removing constraints, reducing batch sizes and eliminating waste. These are all steps taken within manufacturing to increase production throughput and are improvements that software teams can adopt to achieve equivalent benefits.

  • Visually Staffing Your Developer Teams

    Visually Staffing Your Developer Teams

    Effective collaboration within developer teams is key to creating and improving any product, so who you choose to put on the team—and how it’s structured—can make a huge difference. There are many considerations that go into these decisions, and the challenge is even greater thanks to the widespread movement to a hybrid work environment. To make the process a bit easier and more transparent and to set teams up for success from the outset of each project, it can be helpful to use a visual approach to staffing. 

    Considerations When Assembling Your Team

    When a general manager is assembling a team in professional sports, they must take into account personalities, abilities and leadership styles to make sure the team functions smoothly and can win games. There are similar considerations necessary when putting together a developer team.

    For example, a team must have the right balance of expertise. Having a team that is loaded with frontend experience but little to no backend experience will likely prove problematic. Also, a team full of interns or entry-level engineers with few or no senior engineers won’t have the leadership and expertise needed to succeed.

    Coding styles are also a major consideration when assembling teams. Some engineers may be “cowboy coders”—coders who aren’t afraid to take risks when developing a product. Other engineers, however, may suffer from “analysis paralysis,” spending too much time making sure the code is as perfect as possible. It’s important for teams to have a mix of these styles so the development process doesn’t lean too far in either direction and so the overall team has the right balance for the project at hand.

    Using Visual Collaboration to Assemble Teams 

    As a development team leader, I’ve found staffing our teams using a visual approach—and visually collaborating within those teams—is invaluable. It makes it much easier to ensure we have the right expertise and coding style on the right teams while managing the fast-paced changes that are a reality in today’s business environment. And with the staffing for each project visualized, leaders and team members can easily see who leads the projects and how many people are on each team within those.

    Managers or project leads should be able to see all of the relevant factors of staffing before making an informed decision on who should be on the team or if they need additional support. To begin visually staffing your teams, start with a diagram that—in addition to displaying which team each person is on—clearly shows each individual’s responsibility and flags if they’re new to the team. When decision-makers are able to see each of these factors at a glance, it helps them quickly determine if a team has a gap and needs additional support. 

    Caption: Here, team leaders can see team breakdowns, responsibilities and if someone is new to the team (Lucidchart)

    To make visual staffing even more effective, you may want to get more granular in detail when viewing team structures. This could include labeling team members with relevant attributes such as title, seniority, location, etc. Therefore, if a team needs a senior engineer or someone who’s worked on similar projects, it’s possible to quickly drag their name on your diagram and place them on another team. With this method, teams can see how a new assembly of talent can work together and how this adjustment affects other teams. 

    Caption: Team leaders can identify personnel, job title and the reporting structure (Lucidchart)

    We’re also able to diagram reporting structures. It’s important to know to whom each person reports and how many direct reports each leader has. This helps prevent burnout and ensures each manager has the bandwidth to lead their direct reports and be in touch with the needs of the team.

    Once teams are created, work sessions, such as program increment (PI) planning meetings, will also benefit from a visual collaboration solution such as a virtual whiteboard. Before the recent predominance of hybrid and remote work, many planning meetings included in-person discussions in front of a physical whiteboard. Also, voting on decisions included physical, color-coated sticky notes which each person would place on the whiteboard to indicate their vote. 

    Caption: Developer teams can participate in virtual PI planning meetings for more seamless collaboration. (Lucidspark)

    Using visual collaboration will help not only recreate this experience in a hybrid environment but also make it more effective and efficient. For example, working with a virtual whiteboard solution could improve a team’s experience with common project management tools, such as Jira. The right visual collaboration solution can allow teams to pull stories and display the latest project information for everyone to provide input directly within a collaborative space. The result is an ability for team leaders to create high-level plans with both real-time collaboration and asynchronous input from teams around the world—all while massively reducing the slow, manual steps that are so common with collaboration in front of a physical whiteboard. Those slow manual steps could include transferring stories from project management software onto physical cards, moving those cards around as discussions continue and then—once decisions are final—manually uploading new information back into Jira or another project management tool. With the amount of dependencies on developer teams today, removing these steps in favor of more efficient processes is invaluable. 

    Visually Staffing Your Teams 

    Staffing teams and enabling collaboration can be a smooth experience, even in a hybrid environment. I’ve found that visualizing how teams work together provides the clarity needed to make the best decisions. It also allows easy changes to team composition should it be necessary. Visually staffing teams allows team leaders to start developers off on the right foot and consistently work toward project goals from start to finish.