Author: Jeffrey Keyes

  • Product vs. Project: Balancing Management Roles for Success

    Product vs. Project: Balancing Management Roles for Success

    Many businesses today rely on project management to ensure that all the activities that are required to help the business function are able to do so efficiently. The importance of project management is ingrained into many businesses, and doesn’t need to be justified—or does it? For software development companies, product management also needs to be considered just as much, if not more. To determine whether both or one is needed, and to what extent, business leaders need to first recognize the similarities and differences between the roles of the project manager versus the product manager, and what each can bring to the business.

    The key to understanding the differences starts with the descriptive writing mantra that everyone learned back in school: the 5 Ws (and 1 H), otherwise known as who, what, when, where, why and how. Though the who and where are generally self-explanatory, you can easily understand the difference between product management and project management by understanding which of the other four questions each job answers. Both positions fulfill critical roles in effective product delivery.

    Product Management: Getting Concrete Answers

    Product management answers the questions of “what” and “why.” These are important because, for every product you build, you need concrete answers to these questions.

    What

    The fundamental question that we’re asking here is, “What are we building?” Many enterprises have a product range that spans across dozens of different markets. Though this is great for the business and investors, it’s not an effective way for a team to work. When you ask a team to build or support a product, they need a clear vision of what that product will actually do. This is especially true for software products because it’s easy for them to lose their identity if they attempt to do too much.

    In a big enterprise, a “do everything” mentality can cost more over time. It’s likely that you have many software teams, and each one is building software that’s designed to suit a specific part of the market. When those teams implement software that duplicates some functionality already provided by your business, you’re wasting time and effort.

    This is where a good product manager is valuable. They help keep software teams focused on what they’re building and rein in the desire (by developers and executives alike) to grow the software outside the job it needs to do.

    Why

    The other major question that product managers answer is, “Why are we building this?” For developers, why is often more important than what. Work is almost always interconnected with the work of other teammates. When teams understand why they’re building something, it’s much easier to understand how those connections should work. It also gives developers information about which trade-offs they should make when implementing a feature, such as simplicity and usability versus speed.

    It’s the job of the product manager to understand and convey the why of the product. They do that by conversing with executives and project stakeholders to understand how this product fits into the overall business need.

    Project Management: The Thoughtful Side

    Project management, on the other hand, answers a different set of questions. A project manager’s job is focused on the how and when.

    How

    Large software projects are complex, with many interdependent and interlocking pieces. Efficient software project managers understand those interdependent requirements and plan for them. They organize the project’s tasks so that by the time someone is ready to work on one piece, its dependencies have already finished. Developer downtime is minimized and it enables those developers to focus only on the problems they need to solve for each task.

    Managing these kinds of interdependent requirements is the most valuable thing that project managers do for their software developers, though it can often be missed by executives, who are much more focused on the second project management question: when?

    When

    This is the visible project management question, “When is that project going to be done?” External stakeholders don’t care about how or why. They usually only care about what when the final product isn’t what they expected. But when is a question that’s top of mind for every single team leader who waits for a software project to be finished.

    This is also the most difficult question to answer. It’s almost impossible to reliably predict how long it will take to deliver a feature—not even a whole project, just one part of it. Something that seems simple at the outset turns out to be much more complicated. Alternatively, sometimes something you think might take two weeks instead takes only a day or two.

    The Balancing Act

    In most traditional cases, both product and project management are crucial for software delivery pipelines to run smoothly. However, many enterprises are now moving their deployment infrastructure toward a continuous delivery model, which adopts DevOps principles. For teams that practice continuous delivery, the question of when something is coming out can sometimes feel less important. Additionally, many software teams transition toward agile software principles, which makes the collective software team responsible for the question of how. Third-party planning tools can also make it easier for software teams to answer the how and when questions for themselves.

    For this reason, many teams are transitioning away from using dedicated project managers. Instead, they move much of that responsibility to the teams and focus their planning efforts on the product itself. However, the most successful projects answer all four questions effectively. When you don’t have a good answer to one or more of these questions, the project can end up stressful and frustrating.

    The people answering these questions might change over time, as it has changed already. The crucial point is to just ensure that you do have people who are dedicated to solving these questions and relaying this information to their teams. This is the smartest way to ensure projects stay on track and deliver the product that is expected and needed.

  • How to Achieve a Converged Toolchain

    How to Achieve a Converged Toolchain

    In recent years, there’s been an explosion of tools for developing and delivering software. In a single pipeline, a company will have separate tools to ideate, plan, code, verify, configure, release and monitor new software, and every pipeline can have different tools for each individual stage (i.e. ideation). That’s a lot of tools, and providing visibility into the process of application development and delivery is difficult and can create many challenges.

    The key to eliminating these challenges is to develop a converged toolchain.

    What Is a Toolchain?

    A toolchain–in the context of software delivery–is a collection of tools managing the planning, execution, quality and delivery of the software being developed, starting from idea generation all the way to production. Each phase of development can have numerous tools, and it’s not uncommon for an organization to use multiple test tools, multiple tools for backlog/user story planning or multiple defect tracker tools.

    By default, each tool operates in a silo–not really interacting with other tools and not visible to other groups. Without a converged toolchain, companies are left with fragmented visibility along the application development and delivery pipeline. This means the development team has no idea what the planning team is doing, the operations team can’t see what’s happening with the development team, and so on. Of course, someone from the development team could walk over to the planning team and ask, “what’s going on?” But that halts momentum and slows down the entire process.

    The Kanban framework is a great example of a siloed tool commonly used in planning. It presents a list of all the features that need to be built, but it can’t track features in production unless someone manually changes a status. Thus, it’s only as reliable as each person making the updates, and it results in the status of many projects being out of date and stale.

    The service desk is another good example. Here you’ll find which projects are in or about to be in production, but it leaves you with very limited visibility into what’s coming down the pipeline. It also doesn’t provide you with context. For example, the operations team may know what app they’ll be working on, but they don’t have an idea of the risk profile of what’s coming.

    Benefits of a Converged Toolchain

    With a converged toolchain, disparate and siloed tools can work in one connected ecosystem. Help desk tickets can match a bug to the specific developer who worked on the feature, and initiatives can be matched to applications, environments and/or production change requests. The convergence of tooling data enables visibility between groups–allowing each group to use their own tools but at the same time work with data that is augmented from the rest of the toolchain–and this visibility enables collaboration between the groups. Connected toolchains also enable each team to continue to work on their part of the process using their own tools, and teams can evaluate the entire process of software delivery and monitor for hand-offs, waste and inefficiencies. This holistic visibility enables efficiencies not previously possible. 

    Without a converged toolchain, teams are likely to run into problems around timing and planning. For example, when the testing team is ready to tackle their part of a project, their first questions are typically, “what environment is it on?” and “what features does it include?” Unfortunately, these can be some of the hardest questions to answer. But a converged toolchain allows the testing team to easily see where exactly the unverified feature is, ­­and quickly move it along the pipeline.

    Achieving Convergence

    By converging the toolchain, you’re integrating and interconnecting the tools in the toolchain. To achieve this, you’ll need to complete three steps. First, you need to correlate and integrate data from the tools into a common data model. This will help create a standard way of looking at features, tests, environments, release processes and phases of delivery. All of these tools need to feed into their part of application delivery so you can correlate all the data together.

    Once you have that, the second step is to synchronize data between the tools and bring all the data into your common data model. This will give you the visibility your teams need so you can connect particular features to the environments they are on or know what features still need to be built.

    The third step is to create workflows. This allows you to not only bring data in but also take action on the data and react to things based upon events. For example, when the operations team is transitioning a new feature to production, they can mark it as ready for production, and it will be labeled that way across all tools and all teams. This ensures every team is on the same page and no piece of work can become stale.

    This workflow can also help when it comes to issues that are reported to an organization’s help desk or technical support of internal applications. Without a converged toolchain, that help desk worker has to create a ticket, call up to the developer team and try to track down the person who can fix the issue. However, with a converged toolchain, that help desk worker can automatically create an alert for the developer of that system. Then the developer is able to quickly see the bug, begin working on a hot fix and send a note back to the end user with an estimated time of completion. All of this is completed within the workflow of the converged toolchain and without anyone having to physically chase down another person for answers.

    By restricting themselves to only living in silos, most organizations have created a problem when it comes to communication and workflow across teams. Instead of working on items that deliver value to their customers, teams are spending a considerable amount of time on hand-offs. While it is important to know where a project stands, teams should be focused on delivering value to the customer, not gathering status updates.

    The days of living with this kind of fragmented visibility into the application development and delivery process is not acceptable anymore. Every organization’s toolchain should be focused on removing execution barriers and automating the development and continuous delivery process. In order to achieve this kind of success, teams need to be able to work with full transparency in their tool of choice while also being able to see the broader context of how their work fits in to the rest of the toolchain. With a well-designed, integrated and automated DevOps toolchain, development and operations team members are able to work together with common objectives and metrics to ensure quality, on-time application delivery to the customer.

    — Jeffrey Keyes

  • Is Release Management Dead in the DevOps World?

    Is Release Management Dead in the DevOps World?

    In the world of enterprise application development and delivery, release management was born from the operations team attempting to reduce risk in the delivery pipeline. It’s the operations team’s job to ensure all production runs are stable, while the development team focuses on creating and shipping new products and applications.

    While this seems well-defined, integrated DevOps teams are left to wonder if they need release management, and how it fits into their processes. The answer is a resounding yes–release management is a crucial aspect of continuous delivery. Enterprises that fail to implement faster and carefully coordinate release cycles, will ultimately fail to keep up with their competitors.

    What is Release Management?

    The aim of release management is to consider the bigger picture, and to view software not only in relation to how the technology works in its production and during development, but also how it relates to the overall business objectives. It’s about much more than coordinating the creation of new and improved software–it’s also about coordinating all of the resources required, the features and the testing, and understanding how applications progress through the lifecycle. Essentially, true release management is not just about risk. It involves everything required to facilitate software moving into production while coordinating all of the different teams to ensure every release follows company procedures. It also makes sure all of the stakeholders are in communication to understand how the outputs of each individual team work together in the production environment.

    For a DevOps team to fully embrace release management, there needs to be a change in the traditional structure that the teams are used to. Product managers need to take ownership of the deployment process with the ultimate goal to ship finished software. They should own the entire process from start to finish, and thereby become the connection between the business, the customer and the development team. However, product managers are unlikely to be experts at release management, so they need help to fulfill this role effectively. This is where the product-oriented team comes in. As DevOps adoption matures, release management responsibilities need to be transferred to the product-oriented team, though there may still be guidance from a release management group.

    Why Does Release Management Still Exist?

    For businesses that either don’t have a release management system in place, or that struggle with how to make it work effectively, they may question why release management is still a concept, and whether it still needs to be one. Release management is necessary for teams to manage the complex amalgamation of DevOps and distributed microservice-based architectures.

    Businesses today frequently still have monolithic applications, independent from all other applications. Having these monoliths means there are dependencies, and dependencies are the death of anyone trying to run autonomously, as you still have to connect these applications with all of the others. Teams also tend to still have more stable systems of record, including ERP (Enterprise Resource Planning) applications, which are more complex to manage, particularly when changes are being made and if there is a hybrid environment involved with both on-premises and cloud. If DevOps teams do not integrate a suitable release management strategy to cope with this landscape, there can be potentially severe disruptions to day-to-day business processes.

    Where Do Autonomous Teams Fit in?

    Though autonomous teams are becoming increasingly self-sufficient, aspects of the business such as accessibility, security, usability and architecture reviews will never be 100% autonomous. Therefore, these teams will still require some level of guidance. Release managers are beneficial here because they have an overview of the entire process to see how every tool operates individually and alongside others, and can easily spot where bottlenecks are occurring so they can be resolved.

    Not only this, but as mentioned, release management accounts for all of the areas that can’t be automated for one reason or another. To make this work efficiently, businesses will ideally introduce either a coach for the product manager, or a part-time release manager in the product team.

    Whenever people are not available, there are also tools that can be implemented to make this process easier. Having a virtual release manager tool spans all of the delivery teams–it’s a combination of release process orchestration matched up with templatized and standardized releases approved by the release management team. The templates are like the blueprints for the release–they provide an example of how the release should look, creating a foundation that developers can then build on with the specifics of the desired release.

    In addition to templatized releases, you should shift left governance, risk and compliance requirements left in the development and delivery. Create a series of non-functional requirements that help ensure development performs necessary tasks during the development cycle. Tasks such as accessibility reviews of the design, threat modelling or architecture review performed early can reduce risk later on, since any problems to those areas have the potential for large changes.

    So, is release management dead? The answer is no. Though some businesses may be struggling to find a way to implement or adapt this methodology to fit around their existing teams, having the support and visibility of release management and any tools that are introduced can enable applications and the teams working on them to work in harmony, and ultimately improve the value that is delivered to customers.

    — Jeffrey Keyes

  • The Terrain of DevOps is Strewn with Pitfalls

    The Terrain of DevOps is Strewn with Pitfalls

    As Gene Kim, one of the leading thinkers in DevOps, once said, “DevOps is not about what you do, but what your outcomes are.” What he’s telling us is that DevOps is about enabling a rapid flow of work that transitions from development to testing to operations, but the bottom line is that it’s about achieving results. Unfortunately, this too often gets lost in modern-day DevOps practices.

    In this article, I will discuss five common pitfalls that occur in DevOps if you don’t pay attention to the endgame and how your organization can avoid falling victim to them.

    DevOps and Automation: Measuring the Wrong Outcomes

    Some people believe that, at its core, DevOps is about trying to automate everything. But ask yourself this: Once you automate, are you really delivering a better outcome?

    The answer is not always yes. While metrics such as deployment frequency or mean time to repair (MTTR) are interesting DevOps indicators, they are no more interesting to determining if your team is delivering actual value than measuring the number of lines of code submitted or counting the number of keystrokes by the development team. You measure outcomes by determining a baseline from where you start and compare that with where you end.

    We need to understand that DevOps is about much more than automation; it’s about the entire pipeline and how your team moves from ideation to delivery to production. Even large companies with world-class DevOps teams don’t always clearly see the problem and can struggle managing the value stream and putting together multiple pipelines. An anonymous but real-life example of this is an organization I know that had been doing DevOps for 18 months, yet hadn’t delivered anything into production in that span. Are they really doing DevOps? DevOps is a process, but if it produces zero value, it’s not delivering on its promise.

    The key is focusing on delivering value and measuring value delivery into production. However, before you can begin measuring value, you have to define what it means to each individual deliverable. Common metrics include the number of story points, actual revenue from product comparison and customer satisfaction. With your clearly defined metrics in place, you can measure value as it gets delivered to the customer.

    DevOps and Fragile Environments

    One Achilles’ heel in the DevOps process is the pre-production environments where code gets deployed and tested. Automating a delivery pipeline relies completely on code being built and deployed to various environments. Fragile environments mean that the developers and testers are wasting time dealing with problems originating from the environment and not the code itself.

    While we wish all environments could be on-demand; the fact is, most are not. Another DevOps expert, Randy Bias, has an analogy about pets versus cattle in describing servers, and the same analogy can be used for environments. If environments are not standardized and repeatable, you have to be willing to move on from it like a farmer moves on from livestock; you can’t hold onto sentimental attachments like we have with our pets. What’s most important is that in no case can an environment be singular in nature.

    One element of the solution is to create code and automate, but the key is building up environments that are complete. Every environment needs proper builds, proper data and proper tests validating the environment. Additionally, the automation must have the stability to perform successfully every time. If you have piece of automation that fails even just 5% of the time, that’s unacceptable.

    The only way automation works in an environment is if you can trust the environment. When the environment is unstable, it’s like playing Russian roulette: No one knows exactly where the danger lies. It could be in the environment, the code, the data, the middleware … a number of places. When a problem arises, developers are often the last line of defense, but dealing with an issue such as this pulls them away from getting real work done.

    Disconnected Teams

    On this point, I’d like to share a warning: Disconnected toolchains lead to disconnected teams. The planning, development and testing teams can lack cohesion, and the release and operations teams often struggle to be on the same page. Each of these groups have their own tools and management, but they need to be able to communicate with each other effectively to make things work smoothly. In an ideal world, planning initiatives would flow into features for the development and testing team, which would flow into release pipelines and operational changes. Every team still can speak its own language, but the tools need to be interconnected and unified across the teams.

    Mismanaging Hybrid

    The term “hybrid” has many different uses in the software development space. Hybrid methodology refers to combining waterfall, agile and DevOps practices. Hybrid environments means your environment is housed in multiple locations such as the cloud, on-premises, virtual or code. There’s also hybrid geography, hybrid architecture, hybrid style—the list goes on.

    The key to transitioning to DevOps is properly managing the different types of hybrid. If you can’t manage hybrid delivery, you can’t manage your entire delivery and you can’t improve your delivery holistically. Organizations must learn to manage in a world of hybrid delivery and be able to handle cloud and on-prem, as well as teams all over the planet.

    Fixing Non-Constraints

    The Theory of Constraints is about pinpointing the bottlenecks in your process and fixing them. Any work that’s not focused on eliminating the constraint will not result in improvement and could be considered a waste of time.

    It’s important to remember that if you haven’t fixed the bottleneck, you haven’t improved anything. At the same time, if you’re automating the non-constraints, you’re wasting efforts by trying to improve what doesn’t need improving.

    As we’ve pointed out, DevOps does not equal automation. If an organization has messy processes and tries to automate them, they’ll be left with an automated mess. Therefore, organizations will see the best results from automating their constraints and just as important, not automating the non-constraints.

    — Jeffrey Keyes