{
  "version": 3,
  "sources": ["ssg:https://framerusercontent.com/modules/wQkrKbJZUqK24WDRABya/9JJSd55kUCD7308oVHah/VttwVM63r-30.js"],
  "sourcesContent": ["import{jsx as e,jsxs as t}from\"react/jsx-runtime\";import{Link as a}from\"framer\";import*as n from\"react\";export const richText=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Take thousands of developers, distribute them over several departments, and split them up into small teams of 10-20. Now take these 20-50 development groups and ask them to create a distributed, service-oriented architecture. \",/*#__PURE__*/e(\"em\",{children:\"Without a solid approach to test environment management your organization will end up with a \"}),/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-test-environment-pollution\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"em\",{children:\"real \u201Cmess\u201D of testing environments\"})})}),/*#__PURE__*/e(\"em\",{children:\".\"})]}),/*#__PURE__*/e(\"p\",{children:\"Test environments might start off nicely organized, but as teams come and go and systems mature and change over time. You\u2019ll end up with test environment interdependencies that look like a bowl of spaghetti. How do you clean this mess up? Where do you even begin? In this post, I\u2019m going to outline a series of steps you can take to clean up your polluted test environments.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step #1: Create an Inventory\"}),/*#__PURE__*/t(\"p\",{children:[\"The first step in cleaning up your test environments is to \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-test-environment-pollution\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"understand the scope of your problem\"})}),\". How many test environments do you have? How often are they updated? And, what is the process for keeping track of requests for new environments?\",/*#__PURE__*/e(a,{href:\"https://firstround.com/review/The-Dos-and-Donts-of-Rapid-Scaling-for-Startups/\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"If your organization has experienced rapid growth over the past several years\"})}),\", or if you work at a company that has expanded rapidly through acquisitions you might not have a process defined, and you might have several competing ways to keep track. Don\u2019t just create an inventory in a static Excel spreadsheet that will be outdated the second you\u2019ve saved it. Use Plutora and start keeping track of environments and how they relate to your application development teams and the releases they conduct.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Step #2: Define Test Environment Management for Your Organization\"}),/*#__PURE__*/t(\"p\",{children:[\"When you are a \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/the-definitive-hiring-guide-for-test-environment-managers\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"test environment manager\"})}),\" you often feel like you have twenty different bosses each with a different idea of what it is that you do. Some of your application owners expect you to configure and deploy applications to test environments while others are just looking for a few VMs so they can take it from there.\"]}),/*#__PURE__*/e(\"p\",{children:\"Cut through this confusion and define the purpose and objectives of your test environment management function. Different organizations have different requirements depending on the capability of teams and the applications being supported, but you need to communicate with all of your customers. What services does test environment management provide. Who is responsible for VM creation? Who is responsible for release management and deployment? Answer these questions as part of your cleanup effort.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step #3: Assign Responsibility\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://en.wikipedia.org/wiki/Responsibility_assignment_matrix\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"RACI diagrams\"})}),\" are a necessity. For each of your test environments record who is responsible and accountable. Then keep track of who needs to be communicated with and who needs to be kept informed of changes. Plutora is the tool that allows you to associate a RACI matrix with every test environment so that you can ensure no environment will fall through the cracks and become another, polluted and unused system.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Step #4: Isolate Your Networks!\"}),/*#__PURE__*/t(\"p\",{children:[\"One of the most prevalent and dangerous practices in the industry is \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-test-environment-pollution\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"mixed test environments\"})}),\". This is when a QA or a Staging system interacts with production services and databases. These mixed environments occur when test environment managers run out of resources and teams are forced to piece together testing systems that span multiple environments.\"]}),/*#__PURE__*/e(\"p\",{children:\"Avoid this by asking your infrastructure teams to segment your testing and QA networks from production. You never want to connect a QA system to production, and with environment pollution this practice becomes dangerous because you can start to lose track of the boundaries between QA, Staging, and Production. Isolate your QA, Staging, and Production networks and you can start to clean up polluted test environments without having to worry about production impact.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step #5: Establish a Common Policy for Application Owners\"}),/*#__PURE__*/t(\"p\",{children:[\"The most difficult part of being a test environment manager is r\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/can-get-another-qa-environment-tomorrow\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"esponding to an almost constant request for environments.\"})}),\" Everyone will always need more QA and staging environments, and sometimes you have to say no. If you have a defined policy for resource allocation it will make these conversations easier. Define a set of expectations for application owners. How many QA environments can you make available to a development group? How can they justify requests for more environments? What is your exception policy for test environments if someone needs a temporary allocation of excess capacity?\"]}),/*#__PURE__*/e(\"p\",{children:\"It\u2019s often easy to say yes to every request that comes your way, but if you do this you\u2019ll find yourself running out of hardware for other projects. A policy for test environments helps you control your spend on hardware, and it also helps avoid situations where application owners feel free to ask for an unreasonable number of testing environments.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step #6: Divide and Conquer\"}),/*#__PURE__*/e(\"p\",{children:\"If you work at a large company with thousands of developers you likely have 20-50 internal customers. Don\u2019t treat each of them as a unique customer as this approach rarely scales. Try to group them into departmental or functional groups. You might have 10 customers all working on the same type of application in the same department. If this is the case, group them together and assign a single individual as your point of contact for these releases.\"}),/*#__PURE__*/e(\"p\",{children:\"You may also have many, cross-functional teams that all release at the same time. They are working on different technologies, but they will always be coordinated to perform releases on the same product. Or, you might have several independent teams all sharing the same technology platforms. Find commonalities and intersections across your customers and look for ways to streamline the process for everyone.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step #7: Tame Your Testing Data\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/test-environment-management\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Test environment management \"})}),\"is made easier when you have an automated approach to creating test data. In fact, if you don\u2019t have a good approach to test data and data masking it makes it much more difficult to achieve the sort of agile approach to test environments management that development teams expect.\"]}),/*#__PURE__*/e(\"p\",{children:\"Don\u2019t just focus on deployment automation and efforts to make your application servers more agile. Involve your DBAs in the conversation surrounding test environment management. Make sure that they understand the importance of keeping up with advancements in infrastructure automation, and don\u2019t take on the task of test environment database administration as part of test environment management. Use Plutora to identify just how much support test environments need from DBAs and use the tool to justify resource allocation to avoid outdated QA data sets and systems that are not synchronized with production.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step #8: Claim Your Victory\"}),/*#__PURE__*/e(\"p\",{children:\"Now that you have your test environment management situation under control and you\u2019ve reduced contention between different projects it is time for you to lay claim to your success. Calculate the annual cost savings you\u2019ve achieved either in terms of increased productivity or reduced spend on hardware. Make these figures visible to your management so that they can appreciate the increased productivity that is the natural outcome of your upgrades to test environment management.\"}),/*#__PURE__*/e(\"p\",{children:\"Always take time to justify test environment management as these costs are often seen as unavoidable or hidden over the course of many years. Every CIO or CTO likes being surprised with new opportunities for cost savings and test environment management needs to be acknowledged as an important part of reducing waste within your department.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step #9: Establish Regular Reviews\"}),/*#__PURE__*/e(\"p\",{children:\"Polluted test environments are a natural by product of application development, and you\u2019ll need to establish a weekly and monthly cadence of review sessions to make sure that all of your test environments are accounted for. Start a weekly meeting to assess test environments health and identify environments that may no longer be necessary. Then think about having a quarterly meeting to look at your test environment KPIs.\"}),/*#__PURE__*/t(\"p\",{children:[\"The best defence against Test Environment pollution is a good offence. Pay attention. Keep track of your policy and the exceptions to your policies. Communicate the rules of the game to your customers, and stay vigilant. \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/test-environment-management\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Use Plutora to stay on top of test environment pollution.\"})})]})]});export const richText1=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"In an environment where infrastructure is shared across several development teams test environment conflict happens when more than one project needs to use test environment resources at the same time. It can also occur when competing release trains of the same project have overlapping test environment requirements.\"}),/*#__PURE__*/e(\"p\",{children:\"Test environment conflict is a common cause of project delays during the later stages of the application development lifecycle and can be one of the main reasons why projects miss critical deadlines. Test environment conflicts cause delays that can cascade across multiple projects and departments especially when emergency fixes for production introduce delays that are passed on to every project currently awaiting access to test environments.\"}),/*#__PURE__*/e(\"p\",{children:\"When projects of a higher priority preempt other projects currently making use of test environment infrastructure this can cause delays because of the context shifts that are required to teardown and set-up test environments for particular projects. These conflicts are a common source of tension between different departments and application development projects and can also cause QA to be rushed and incomplete leading to an overall decrease of software quality.\"}),/*#__PURE__*/e(\"p\",{children:\"On this blog we\u2019ve discussed the analogy of airport runways and the sequencing of landings and takeoffs for small and large planes alike. Just like an airport runway, projects with emergency releases take precedence over other projects and problems often occur when miscommunication places two projects on the same test environment at the same time. An organization suffering from frequent test environment conflict gives application developers the same experience as being stuck in an airport during extreme delays. Otherwise, productive application development teams are forced to fly in a holding pattern for days or weeks while other projects consume shared resources.\"}),/*#__PURE__*/e(\"h2\",{children:\"Preventing Test Environment Conflict\"}),/*#__PURE__*/e(\"div\",{children:\"https://youtu.be/mTxh76GqIWc\"}),/*#__PURE__*/e(\"p\",{children:\"Test environment contention or conflict is prevented by having an accurate picture of the progression of all projects towards release events. Once test environment managers and release managers start using a tool such as Plutora to track project status on a central, consolidated dashboard they can accurately forecast the demand for test environments over time. As projects approach QA, QA integration, and staging milestones test environment managers can give all projects information about availability and possible conflicts in advance to avoid the last-minute test environment surprises that can paralyze an IT department.\"}),/*#__PURE__*/e(\"p\",{children:\"The occurrence of test environment conflicts can be reduced through the use of dedicated, persistent environments for individual projects. If a project has a regular cadence of release events it is more likely to maintain a stable set of test environments to support a continuous process of QA and Staging. If a project has an infrequent or irregular release schedule it is likely only able to qualify a production release when a shared QA or Staging infrastructure resource is made available.\"}),/*#__PURE__*/e(\"p\",{children:\"As more organizations move towards cloud-based infrastructure and deployment automation technologies test environments can be created and disposed of on-demand by individual development teams using self-service platform-as-a-service tools and configuration management frameworks. In these organizations, test environment conflicts can be avoided by allowing teams to dynamically increase infrastructure capacity on public or private clouds.\"}),/*#__PURE__*/e(\"p\",{children:\"While this is an increasingly common pattern, even the most advanced organizations continue to support test environments for legacy applications installed on bare metal servers that are neither agile nor amenable to on-demand provisioning. If an organization is resource constrained for test environments it must use a rigorous approach to planning and forecasting test environment infrastructure to avoid contention and conflict.\"}),/*#__PURE__*/e(\"p\",{children:\"One of the primary goals of both release management and test environment management is to avoid delays due to test environment resource constraints. Through a combination of communication, transparency, and metrics test environment contention can be dramatically reduced and exponential gains in productivity can be achieved through the use of tools like Plutora to give all parties an accurate, up-to-date picture of test environment usage and projected demand.\"})]});export const richText2=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"A deployment manager on the largest of projects is a project manager who assumes responsibility for managing deployment playbooks and making sure that the sequence of event during a release process are run properly. But, there\u2019s more to it than that. They are also expected to be a technical assessor of risk, and they need to be great at translating between technical specialists and executive management. They are the person most likely to have to think \u201Con-their-feet\u201D when a deployment doesn\u2019t work as planned. When the DBA is on a conference call trying to explain why it will take an index three hours to rebuild after a DDL statement has been executed, it is the deployment manager who often has to make an instant decision to Go/No-Go. (They also have to translate DBA to MBA.)\"}),/*#__PURE__*/e(\"p\",{children:\"Your Deployment Manager is the most forward-deployed manager responsible for moving the organization toward a more automated, DevOps-ready posture. They are the managers who can tell teams to stop conducting multi-hour manual deployments and start investing in the tools that will allow your business to release faster and more frequently.\"}),/*#__PURE__*/e(\"p\",{children:\"Your deployment manager is going to be responsible for a team of engineers and answerable to release managers and executives focused on risk mitigation and reduction of release-related downtime. They are going to get you out of the legacy support mess that many find themselves in by hiring the right team to apply modern automation to your systems. There\u2019s a lot riding on your deployment manager, so it\u2019s important to hire the right individual.\"}),/*#__PURE__*/e(\"h2\",{children:\"Deployment Manager Job Description\"}),/*#__PURE__*/e(\"p\",{children:\"Here\u2019s what we would list if we were currently seeking the right candidate for a deployment manager position:\"}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Seeking a qualified technical manager to coordinate deployments to environments supporting ongoing application development. As a deployment manager this individual would be responsible for supporting deployment for several application development groups delivering software continuously to staging environments, QA environments, and highly available production environments. The position will also involve the creation of common standards for deployment of applications across a number of platforms and technologies including, but not limited to, system architectures involving Java, .NET, and back-office systems using dynamic languages such as Node.js and Ruby on Rails.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Candidates must be able to understand high level software and system architecture, but will not be expected to participate in day-to-day development or operations. Deployment managers will be responsible for taking software from source control, CI/CD systems, and binary repositories and building systems to automate the deployment of software to infrastructure with a minimum amount of release-related downtime. Looking for a motivated technical manager who is able to quickly adapt to rapidly changing technology and who is able to build a team of focused release engineers and deployment specialists to create automated playbooks for deployments.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Candidates should have several years of experience in release engineering with prior responsibility for revenue-generating systems in production. Individuals should also have an understanding of release engineering that spans both software development and system administration as they will be interacting with both developers and operations professionals in addition to project managers focused on release management. Candidates should have a proven track record of managing teams and creating on-call schedules for release support activities.\"})})]}),/*#__PURE__*/e(\"p\",{children:\"Note that we didn\u2019t mentioned DevOps and that we\u2019re light on technology in this job description. The real focus of a deployment manager\u2019s job is to plan, assess, and delegate activities to others. In a large business you want a deployment manager to be managing others and not getting overloaded with too much technical involvement. For this reason we\u2019ve listed some of the technologies that might be found in an enterprise environment, but our recommendation is to seek qualified talent and use your interview process as an chance to drill down into the technical qualifications.\"}),/*#__PURE__*/e(\"h2\",{children:\"Roles and Responsibilities\"}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Manage a team of release engineers and deployment specialists\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Allocate resources among several projects to support ongoing requirements for deployments across multiple departments\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Assess and audit existing release processes\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Develop deployment playbooks for critical applications\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Evaluate production risks associated with production deployment activities\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Support staging and QA environment deployments through automation\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Identify opportunities for the automation of existing deployment processes\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Communicate with DBAs and other roles dedicate to support of store, networking, and database systems.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Accompany all new application architectures and deployments with contingency plans and deployment playbooks to execute in case of failure\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Prepare specialized deployment processes to support disaster recovery and business continuity scenarios.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Conduct quarterly reviews of deployment activities and deployment operations\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Identify root cause for deployment-related downtime and participate in after-action reviews for production deployment activities.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Create an on-call schedule for deployment and release engineering resources to support production.\"})})]}),/*#__PURE__*/e(\"h2\",{children:\"What skills to look for when hiring a deployment manager?\"}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Attention to details, but more important than that is a commitment to precision.\"}),\" A deployment manager is much closer to the implementation details than a release manager as they will be responsible for directing others to make changes in production.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Ability to assess risk, immediately.\"}),\" Software systems are complex, and you will never be able to fully anticipate the ramifications of every change ahead of time. A deployment manager needs to be able to rapidly assess the risks and impacts associated with a change in plans almost immediately.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Technical aptitude.\"}),\" A deployment manager isn\u2019t going to run deployment scripts, but they should understand the rapidly changing landscape of tools that are used to automate deployments and they should be quick learners. You don\u2019t want a deployment manager running scripts themselves, but you also don\u2019t want a deployment manager who doesn\u2019t understand the fundamentals. If a new NoSQL database has deployment problems, you want someone who can get up to speed quickly.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Ability to motivate teams in challenging situations.\"}),\" Even with meticulous planning a highly orchestrated production release is still a high risk, high pressure event. Make sure to find a deployment manager who is able to motivate teams to focus and deliver in a high pressure environment. You are looking for a manager who can communicate urgency and keep a team focused on a release process while also encouraging people to stay calm. Releases often happen in the middle of the night, or during an emergency, and your deployment managers are the ones in the middle of the tough situations.\"]})})]}),/*#__PURE__*/e(\"h2\",{children:\"Who is the Ideal Candidate?\"}),/*#__PURE__*/e(\"p\",{children:\"With technologies changing as fast as they are a good candidate for a deployment manager position is going to be someone with a technical background. This job is going to involve supporting a number of legacy systems in addition to new systems that are changing faster than anyone non-technical can keep up with. New deployment technologies such as Docker and other approaches to containerization have the potential to change this focus area very quickly, and you are going to want to recruit a candidate who doesn\u2019t have to have these technologies translated for them by more technical resources.\"}),/*#__PURE__*/e(\"p\",{children:\"You are also going to want to recruit a candidate who can cover for their release engineering resources in the even of an unanticipated problem. Deployment managers will have ongoing responsibilities to work with application development groups on QA and development deployments, they will need to be able to discuss changes in application architectures that require changes to deployment playbooks, but they will also have some exposure to production support. If a system experiences unanticipated failure in production a deployment manager will need to be available 24/7 to coordinate emergency releases that may be required to address failure.\"}),/*#__PURE__*/e(\"p\",{children:\"For the reasons listed above, our recommendation is to hire or promote a technical release engineer who has demonstrated the necessary leadership abilities to manage other engineers.\"}),/*#__PURE__*/e(\"h2\",{children:\"Where should you seek candidates?\"}),/*#__PURE__*/e(\"p\",{children:\"Your best bet to find good deployment manager candidates is a local DevOps event or a conference. DevOps professionals have had a few years of experience automating systems and developing the appropriate communication skills across both development and operations. Identify a candidate who has had experience with automation and who understands that the next several years in the industry are going to involve a lot of work to transition less DevOps-ready architectures to more modern approaches to automation.\"}),/*#__PURE__*/e(\"p\",{children:\"Other venues to seek qualified deployment managers would be forums devoted to the discussion of DevOps best practices. LinkedIn has a number of groups devoted to DevOps, and GitHub is full of profiles of professionals devoted to the creation of new tools and techniques. Again, it is our recommendation that you identify a senior technical resource who is interested in moving into a management position to be your deployment manager, they will be in the best position to assess and recruit the talent you need to move toward a more automated approach to deployments.\"}),/*#__PURE__*/e(\"h2\",{children:\"Who not to hire?\"}),/*#__PURE__*/e(\"p\",{children:\"Don\u2019t hire a non-technical project manager for this role. If you do this, you\u2019ll find yourself on the phone in the middle of a high-risk deployment operation talking to someone who will tell you that they don\u2019t understand what the DBAs just told them. This job requires technical know-how.\"}),/*#__PURE__*/e(\"p\",{children:\"Don\u2019t hire a technical specialist who is going to disappear behind a Terminal and just write the script themselves. A deployment manager is in command of the bridge during a high profile release, they need to understand how to communicate to your front-line engineers as well as how to rapidly relay status and risk assessments to executives.\"}),/*#__PURE__*/e(\"p\",{children:\"You want a technical communicator in this role, and you should take the time to find the right person for this job. No pressure, but a wrong hiring choice for deployment managers is going to cost real revenue in the form of downtime.\"})]});export const richText3=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Environment \u201Cshortages\u201D always start with a test environment emergency \u2013 some unforeseen need for a new environment. Maybe a high-profile project has both an urgent production bug to fix and an unrealistic deadline to meet at the same time. This project\u2019s QA and staging environments can\u2019t be disturbed to fix production without ruining a schedule and someone approaches environment management with a request: \",/*#__PURE__*/e(\"em\",{children:\"\u201CCan we get another environment set up, quickly?\u201D\"})]}),/*#__PURE__*/e(\"p\",{children:\"As an environment manager it is your job to plan ahead and enforce policy, but there are just some battles you are not going to win. This is one of them. While you can tell the project that no environments are available you\u2019ll end up getting blamed when either the production bug isn\u2019t fixed or the project can\u2019t meet a critical deadline.\"}),/*#__PURE__*/e(\"p\",{children:\"How you prepare for emergency environment requests makes the difference between your success and failure as an environment manager. Here are some steps you can take to prepare for emergency environment requests:\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Survey your biggest customers and plan for the unexpected.\"}),\" The larger the project the more unpredictable your environment demand will be. While some projects are very straightforward every organization has a few \u201Cmega-projects\u201D projects like a central web site that have a dynamic release schedule supported by hundreds or thousands of developers. Make sure to reserve capacity for unexpected scheduling changes or bugs for these larger, more-dynamic projects.\",/*#__PURE__*/e(\"strong\",{children:\"Set aside some hardware and resources for the unexpected.\"}),\" Model your application\u2019s needs and set aside enough excess capacity to deal with unexpected situations. If you are developing a web site that interacts with services make sure that you could spin up a separate environment for all of your system components and make sure that you never reach 100% allocation of existing hardware or cloud-based resources.\",/*#__PURE__*/e(\"strong\",{children:\"Plan for two test environment emergencies.\"}),\" Emergency environment requests are often made in response to a critical production bug. \u201CWe can\u2019t disrupt ongoing development, and we need a new environment ASAP.\u201D When problems start happening in complex systems they tend to happen in clusters and you need to be ready to handle more than one unanticipated emergency at once.\",/*#__PURE__*/e(\"strong\",{children:\"Use cloud-based resources as your emergency \u201Cchute.\u201D\"}),\" Today\u2019s large enterprise is a hybrid of in-house resources and systems running on a public-cloud. If you have access to a public-cloud such as AWS or Azure take the time to deploy staging and QA environments to a public cloud. This will make it easier to add additional capacity for an application as VM resources can be created quickly.\",/*#__PURE__*/e(\"strong\",{children:\"Complex projects often require an emergency environment on standby.\"}),\" If you have a web site that delivers to production in weekly or biweekly delivery cycles you may already have an emergency environment on standby. You need to guide your customers through a cost-benefit analysis of maintaining a dedicated emergency fix environment. If a project wants to maintain an aggressive release cadence while maintaining the ability to respond to production bugs quickly you\u2019ll need to budget for an emergency standby environment. Emergency standby environments will often seem like a waste of resources, but they are a necessary insurance policy that will make it possible to handle and react to an emergency without disrupting ongoing development.\",/*#__PURE__*/e(\"strong\",{children:\"Don\u2019t advertise your excess environment budget.\"}),\" If you\u2019ve planned ahead and you have enough hardware to support a few emergency test environments make sure you don\u2019t openly advertise this. Large organizations are always hungry for more resources and as soon as you advertise that hardware is available projects will request it. Keep your emergency supplies available for a real emergency or else they will become some project\u2019s third QA environment (that will go unused for several months.)\",/*#__PURE__*/e(\"strong\",{children:\"Use Plutora to plan out your Environment Management needs.\"}),\" Our system allows you to model the environment requirements of every application team independently. Once you\u2019ve modeled these requirements at the project level you can take a step back and assess your entire organization\u2019s environment requirements. For many of our customers it is the first time they are able to accurately predict what it will take to support hundreds of projects across several departments. With Plutora you can create more accurate environment forecasts and you can predict which projects are going to have conflicting environment requirements. With this insight you can avoid test environment emergencies.\"]})]});export const richText4=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Software releases are the single biggest factor contributing to downtime across all industries. Almost without exception whenever you hear of a high-profile outage with a bank or an airline it is almost always related to a software release or a high-risk change being made to a system.\"}),/*#__PURE__*/e(\"p\",{children:\"While organizations can put quality checks and governance gates in place to prevent downtime there\u2019s always a tradeoff between agility and risk. The most reliable software system would be one that experiences no change at all, but with businesses under pressure to keep up with the competition and deliver more features to customers faster the idea of keeping a system static is unrealistic.\"}),/*#__PURE__*/t(\"p\",{children:[\"If you deliver software to production you understand that releases are risky, and in this post we\u2019re going to provide you with some steps you can take to account for release-related risk. \",/*#__PURE__*/e(\"strong\",{children:\"It may be impossible to reduce your release-related risk exposure to zero, but if you stand up a rigorous approach to tracking release-related downtime it will make it easier to justify greater investment in release management.\"})]}),/*#__PURE__*/e(\"h2\",{children:\"1. Track Key Metrics\"}),/*#__PURE__*/e(\"p\",{children:\"Businesses keep track of expected revenue and activity. If you\u2019ve been in business for longer than a few months you have some expectation for how much customer activity you are going to experience on any given day. If you are a bank you should be tracking the number of customers logging into account management services, performing transfers, and making deposits. If you work in e-commerce you will be tracking orders per minute and other key metrics such as site traffic.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"What Motivates Your Business?\"}),\" Is it traffic or revenue? Are you more focused on traffic and social activity? Or, do you run a business that tracks dollars? These are the questions you\u2019ll have to answer as you instrument your systems to produce real-time data about key metrics. There are some obvious numbers for web sites that should be tracked such as page views per second and error rates for critical systems.\"]}),/*#__PURE__*/e(\"h2\",{children:\"2. Build a Model of Expected Traffic and Revenue\"}),/*#__PURE__*/e(\"p\",{children:\"These metrics will vary over time so you need to build in a model for how traffic changes over a day, week, and year. Here are some of the variations you\u2019ll need to build into your models:\"}),/*#__PURE__*/e(\"h3\",{children:\"2a. Account for Seasonal Variation\"}),/*#__PURE__*/e(\"p\",{children:\"Most businesses follow a seasonal pattern of activity. E-commerce sites get ready for the holiday season, accountants prepare for tax season, and other businesses react to the annual pattern that is present in a given industry. You should also expect there to be seasonal variations and other factors that will affect traffic. An e-commerce site will be busier in November than it will be in April, and you should look at the last few years to establish an accurate Year-over-year (YoY) baseline for daily activity.\"}),/*#__PURE__*/e(\"h3\",{children:\"2b. Account for Daily Variation\"}),/*#__PURE__*/e(\"p\",{children:\"An e-commerce site offering a good deal may see more or less traffic depending on the promotion and how visible it is to customers. When you are establishing your baseline traffic patterns you need to account for the general day to day variation you expect to encounter. This means that your expected traffic or revenue in any given day isn\u2019t a number, it is a range of values based on your experience.\"}),/*#__PURE__*/e(\"h3\",{children:\"2c. Account for New Business and Growth\"}),/*#__PURE__*/e(\"p\",{children:\"As your business expands and offers new products and services and as your customer base grows you are going to have some percentage increase in your business year over year. You are also going to experience differences from one quarter to another. Newer systems may experience an increase in traffic as you transition from legacy systems to new systems, and you should account for these differences in your model. You should also account for marketing campaigns and other activity that may affect your volume of business.\"}),/*#__PURE__*/e(\"h2\",{children:\"3. Establish an Estimated Baseline & Evaluate It Against Reality\"}),/*#__PURE__*/e(\"p\",{children:\"Once you understand how your key metrics vary over different timeframes you can create a model to predict future traffic. Document the assumptions that go into your model. Your model should use historical data over different timeframes to create an estimated baseline for different key metrics.\"}),/*#__PURE__*/e(\"p\",{children:\"Instead of relying on intuition and educated \u201Cguesswork\u201D you should create a system that generates a number. How many page views is your website expecting tomorrow? What is your anticipated revenue? How many errors do you expect between Noon and 2PM? This is the sort of data that you will use when you have to calculate the impact of release-related downtime.\"}),/*#__PURE__*/e(\"h2\",{children:\"4. Account for Release-related Downtime\"}),/*#__PURE__*/e(\"p\",{children:\"Once you\u2019ve selected your key metrics to monitor and you\u2019ve established both a baseline and a predictive model you are ready to start keeping track of release related downtime.\"}),/*#__PURE__*/e(\"h3\",{children:\"4a. First, Mind the Gaps\"}),/*#__PURE__*/e(\"p\",{children:\"The most mature release engineering teams understand how to perform a release to production with zero downtime. This is done by using multiple clusters of systems and swapping systems in an out of rotation in a complex sequence of events. While even the most complex of systems can be adapted to support downtime-free release processes it requires experience and a rigorous planning process.\"}),/*#__PURE__*/e(\"p\",{children:\"Many businesses tend to accept a very low level of downtime during a release. If a database is going to be available for 10 seconds then it might not be worth the time and effort it would take to create a multi-cluster deployment strategy. Alternatively, not every business serves customers with a 24/7 availability expectation. If you run a B2B site and your customers are clustered in a specific region of the world you can schedule releases for off-hours. Sometimes downtime is acceptable.\"}),/*#__PURE__*/e(\"p\",{children:\"For most companies this isn\u2019t the case. As businesses continue to expand to support a worldwide customer base the idea of scheduled downtime or even interrupting a 24-hour business cycle for even a few seconds is unacceptable. No one wants to see a gap in your key metrics that is related to your release process, but when you perform a release and suffer release-related downtime this is just what you\u2019ll end up seeing \u2013 a gap in your key metrics. Where you expected a key metric to remain constant you\u2019ll see it drop. This is why you need to make sure that your operations teams all always tracking key metrics during a release event. It is often one of the first signs that something is working as expected.\"}),/*#__PURE__*/e(\"h3\",{children:\"4b. Capture Availability Problems\"}),/*#__PURE__*/e(\"p\",{children:\"This is the easy part. When your release processes cause system unavailability you\u2019ll be able to see it as a gap in a key metric. Maybe your release happened at 12AM UTC and you have a graph showing expected traffic to a specific subsystem or set of related subsystem trending to zero for 25 minutes. Maybe the release caused a momentary glitch in a database connection that caused a spike in latency for a specific system. These are the impacts you need to capture as issues to be tracked after a release has been completed.\"}),/*#__PURE__*/e(\"p\",{children:\"Shortly after a release you can provide a report to the business on how many minutes or seconds of downtime a release caused and whether this downtime affected customers.\"}),/*#__PURE__*/e(\"h3\",{children:\"4c. Capture Revenue Loss\"}),/*#__PURE__*/e(\"p\",{children:\"Once you\u2019ve identified gaps in system availability you then start the process of relating these gaps to potential revenue loss. Or, if revenue isn\u2019t something you measure, lost trade volume or something similar. Note that I used the term \u201Cpotential\u201D \u2013 revenue isn\u2019t lost when a system fails \u2013 it is missing. You are measuring lost opportunity for revenue assuming that demand would have matched the baseline you\u2019ve created.\"}),/*#__PURE__*/e(\"p\",{children:\"Some of this work will be educated guesswork, especially if the failure condition was partial.\"}),/*#__PURE__*/e(\"h2\",{children:\"5. Act, Analyze, Adapt: Incorporate Failure Analysis into Release Planning\"}),/*#__PURE__*/e(\"p\",{children:\"Don\u2019t just release software and react to release-related downtime. Go into your release processes with a plan. Take time to understand what your key metrics are for system performance and establish a baseline for revenue in a given day or week. When you release software stay vigilant about your key metrics and capture any changes that may be related to your releases.\"}),/*#__PURE__*/e(\"p\",{children:\"Once you get into the habit of tracking metrics during releases and relating problems back to release activities, you can use this data to move your teams toward releases that don\u2019t cause downtime. The goal is to get to a state when releases can happen more frequently without introducing unnecessary risk. If you can establish this \u201CAct, Analyze, Adapt\u201D feedback loop using a tool like Plutora you can take this data and use it to plan future releases. You can identify the teams that cause the most problems and redirect your resources to ensuring that these projects take the time to think about their release processes.\"})]});export const richText5=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"As release managers and executives, we address release complexity and complex dependencies between releases by combining software releases.\"}),/*#__PURE__*/e(\"p\",{children:\"If you have 20 groups asking to run independent releases, why not just combine them all into one?\"}),/*#__PURE__*/e(\"p\",{children:\"Sure, this results in less overhead for support teams, but it also holds the organization back. It\u2019s a limit to agility for teams as they drive toward daily or weekly releases. It\u2019s a \u201Clowest common denominator\u201D approach to release management that is unnecessary when you have the tools available to manage more frequent releases.\"}),/*#__PURE__*/t(\"p\",{children:[\"This \u201Ccombine everything in one release\u201D approach creates more interdependent teams trained to wait for each other to release coordinated changes. If all of \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/whats-release-management-risk-factor-5-questions\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"your releases are combined into one big release\"})}),\", after a certain amount of time has passed you will never successfully separate. A dedicated release management tool\\xa0gives you the ability to break these dependencies by providing the means to manage and track complexity without having to make compromises.\"]}),/*#__PURE__*/e(\"h2\",{children:\"A Concrete Example: The Monolithic Department\"}),/*#__PURE__*/t(\"p\",{children:[\"A company designing a website has 10 different teams working on 10 different parts of the site.\\xa0 There\u2019s a team focused on the e-commerce experience, there\u2019s a team focused on a streaming music service, and there\u2019s yet another team focused on core architecture and services. Each of these teams is a separate, isolated \",/*#__PURE__*/e(a,{href:\"https://en.wikipedia.org/wiki/Value_stream_mapping\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"value stream\"})}),\". Despite this separation, the organization does not understand how to support multiple, simultaneous releases.\"]}),/*#__PURE__*/e(\"p\",{children:\"So they simplify \u2013 instead of allowing each team to move independently they create a monthly consolidated build.\"}),/*#__PURE__*/e(\"p\",{children:\"A year passes and teams have now socialized this process of a monthly release to the point where features are being added across value streams that depend on this monolithic release.\\xa0 Instead of achieving independence to encourage greater agility your teams are \u201Cjoined at the hip\u201D now more than ever.\\xa0 The department is stuck with a monolithic release process.\"}),/*#__PURE__*/e(\"h2\",{children:\"Different Teams, Different Release Schedules\"}),/*#__PURE__*/e(\"p\",{children:\"Combining multiple releases into one is a common practice that limits the overall agility of the organization. Instead of enabling each team to maintain an independent release cadence, the organization standardizes within a single release \u2013 limiting the agility of teams that can and must move faster.\"}),/*#__PURE__*/e(\"p\",{children:\"Here are some examples of different types of teams contributing to software development efforts and what sort of cadence they should be delivering at:\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Content Teams\"}),\" \u2013 Teams focused on content updates and changes to consumer-facing websites need to react quickly to new requirements and defects.\\xa0 These teams should be able to deploy to production multiple times a day to keep up with the pace of change online.\",/*#__PURE__*/e(\"strong\",{children:\"Application Teams\"}),\" \u2013 There\u2019s no \u201Cone-size-fits-all\u201D solution for application teams because there\u2019s such a wide variety of applications being developed, here\u2019s a breakdown of application types with the timelines one should expect to be able to achieve for frequent software releases:\"]}),/*#__PURE__*/e(\"img\",{alt:\"frequent release coordination\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,29HH7BFgBENrfVfA9c48pXXxWHg.png?originalFilename=frequent-release-coordination.png\",src:\"https://framerusercontent.com/images/29HH7BFgBENrfVfA9c48pXXxWHg.png\"}),/*#__PURE__*/e(\"ul\",{children:/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Front-end Web Development\"}),\" \u2013 Similar to content teams, these teams should be able to deliver once a week or once a day.\\xa0 Some high profile websites deliver software multiple times a day.\\xa0 The web moves very quickly and there\u2019s no reason to constrain teams developing web sites to a monthly release process.\"]})})}),/*#__PURE__*/e(\"ul\",{children:/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Server-side Web Development\"}),\" \u2013 Teams developing systems that mediate access to services or other back-end systems. While not as frequent as front-end web development, these teams should be able to achieve weekly release cycles at a minimum\"]})})}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Core Architecture Teams\"}),\" \u2013 Architecture shouldn\u2019t be changing on a daily basis, but this is where a team starts to move to a slower release cadence.\\xa0 A weekly release to address architecture issues or to roll out new features may make sense.\\xa0 These are often the teams that look for a bi-weekly or a monthly release cycle as the changes they are pushing are often high-risk and global in nature.\",/*#__PURE__*/e(\"strong\",{children:\"Back-end Services Teams\"}),\" \u2013 Depending on the risk of a particular system these are also systems that can fall on either side of the release frequency equation.\\xa0 For a low-risk service that supports a website it is possible that a team could achieve a weekly or a daily release cycle.\\xa0 More likely these back-end teams would expect either bi-weekly or monthly releases.\",/*#__PURE__*/e(\"strong\",{children:\"Mobile Application Teams\"}),\" \u2013 Mobile applications, especially native applications, are often released less frequently than once a week, but more frequently than once a month.\\xa0 These application efforts are also difficult to coordinate with other releases because publishing a mobile app often depends on a lengthy submission process to a third-party mobile apps platform.\"]}),/*#__PURE__*/e(\"p\",{children:\"This is just a small number of teams but you see the variation in expectations. Front-end teams can move quickly whereas back-end teams might require lengthy preparation and lead time.\\xa0 The point here is not to force all of these different teams to align and synchronize just to reduce the management burden \u2013 instead\u2026\"}),/*#__PURE__*/e(\"h2\",{children:\"Cut the Cord, Achieve Independence\"}),/*#__PURE__*/e(\"p\",{children:\"With a dedicated release management solution, you can support teams with a more frequent cadence alongside teams that might require a month (or even two) between deployments to production.\\xa0 You do this by taking advantage of the central release orchestration features. In the case of Plutora, these include:\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"A Single Schedule showing conflicts and overlaps\"}),\" \u2013 You\u2019ll have access to a single schedule that will identify potential overlaps and conflicts with other projects and allow you to focus on the overall picture to see how a particular release relates to all others.\\xa0\\xa0 This helps manage risk and release sequence across groups.\",/*#__PURE__*/e(\"strong\",{children:\"An always up-to-date snapshot of release status\"}),\" -\\xa0 One of the most common reasons for moving everyone to \u201Cone big release\u201D is that it\u2019s almost impossible to keep track of release status.\\xa0 When project timelines slip, you\u2019ll need to recalculate a huge matrix of timelines and dependencies. This is \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/resources/videos/plutora-products-overview-demo\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"what Plutora takes care of\"})}),\".\\xa0 It assembles this information from source systems and provides you with an always up-to-date picture of status.\",/*#__PURE__*/e(\"strong\",{children:\"Resource allocation and reports to avoid exhaustion\"}),\" \u2013 You moved to a single release to make it easier on support teams. In the end, these teams still have to perform the same amount of work for a larger, riskier, monolithic release.\\xa0 With Plutora, you can keep track of multiple, simultaneous releases and view their respective statuses alongside their impacts on support teams. This allows you to preserve and protect your most valuable resource \u2013 the people that make frequent software releases possible.In summary, when you \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/evaluate-now\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"use Plutora\"})}),\", you can start managing more granular releases because you\u2019ve gained a window in the release status.\\xa0 Without this necessary view into releases you\u2019ll never achieve more frequent software releases.\"]})]});export const richText6=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Test environment pollution\"}),\" and \",/*#__PURE__*/e(\"strong\",{children:\"test environment churn\"}),\" are two of the biggest factors contributing to delay and inefficiency in test environment management. Test environment churn is a measure of how quickly test environments are changing and the stability of your test environments. Test environment pollution is a measure of how active, up-to-date, and relevant your test environments are across multiple projects. This post focuses on the different kinds of environment pollution and briefly discusses some of the contributing factors for each.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Environment Pollution: Unused Environments\"}),/*#__PURE__*/e(\"p\",{children:\"This is the most common form of environment pollution: environments that sit for weeks, months, or years without being utilized. If you work at a large organization that lacks the discipline to keep track of test environments you\u2019ll encounter test environments that sit idle because no one bothered to inform a test environment manager that they were no longer being used.\"}),/*#__PURE__*/e(\"p\",{children:\"Unused environments are very common in organizations that give development teams access to self-service provisioning tools. Without strong oversight teams frequently over-provision test environments and move on without leaving a note. This is why every test manager should invest in systems to track release and usage activities on test environments. Idle environments consume resources that could be used for other purposes.\"}),/*#__PURE__*/e(\"div\",{children:\"https://youtu.be/JsLMIAlFaVY\"}),/*#__PURE__*/e(\"h2\",{children:\"Environment Pollution: Misnamed Environments\"}),/*#__PURE__*/e(\"p\",{children:\"Modern software architecture is so dynamic and agile development processes can move so quickly that teams can be presented with the challenge of having to deploy multiple branches on a limited number of environments. An example of this is using a staging environment for QA or using a production environment for staging. Some organizations sidestep this problem by using generic names for environments like S1, S2, S3, and so forth, while other organizations name environments after the type of activity they support such as QA01, QA02, Stage01, and Production01.\"}),/*#__PURE__*/e(\"p\",{children:\"Both approaches have advantages and disadvantages, but common anti-pattern is to use named environments for the wrong kind of testing activity. Any time anyone tells you that a production deployment needs to be \u201Cstaged\u201D to production and that the staging environment supports QA you\u2019ll understand how confusing this practice can be over time. If production is staging and staging is QA what happens on QA? A different kind of QA? This creates environment pollution because no one is ever certain if an environment\u2019s name reflects its purpose.\"}),/*#__PURE__*/e(\"h2\",{children:\"Environment Pollution: Mixed Environment Testing\"}),/*#__PURE__*/e(\"p\",{children:\"If you have multiple environment types such as QA, Staging, and Production but you only maintain a single production database to which they all point to you are practicing mixed environment testing. It is a dangerous practice mix QA with production and when you do this you run the risk of losing production data during a QA test run or inadvertently configuring a production system to point to a QA version of a service.\"}),/*#__PURE__*/e(\"p\",{children:\"Mixed environment testing happens where there is little or no segmentation between production networks and testing networks, and in multi-level, microservice architectures there is always an option to just point a QA system to production-level backend services. Mixed environment testing often limits the testing activities you can perform because whether you are mixing staging data with QA data or production data with QA data you need to always be careful not to affect production.\"}),/*#__PURE__*/e(\"h2\",{children:\"Environment Pollution: Unsynchronized Environments\"}),/*#__PURE__*/e(\"p\",{children:\"When a test environment is so far out of sync from production in terms of configuration it isn\u2019t a test environment at all. Test environments should match the configuration of production systems. Take a web site as an example. If your production systems are configured to use compression to serve web content, your QA and staging environments should be similarly configured. If your application is tuned to use a certain approach to connecting to a database in production you should use the same approach in QA and staging.\"}),/*#__PURE__*/e(\"p\",{children:\"When your QA and Staging systems are not configured to match your production systems you are not creating an environment that supports QA. When you test on unsynchronized environments you will be constantly surprised by bugs that appear in production only because no one was able to test a specific approach to configuration.\"}),/*#__PURE__*/e(\"h2\",{children:\"Environment Pollution: Test Environments with Production Data\"}),/*#__PURE__*/e(\"p\",{children:\"In certain industries testing with real production customer data runs counter to several regulations, and, in some cases, the law. In less-regulated industries testing with production data is very common. The idea behind building a test environment with production data is that your QA process should be able to test against a carbon-copy of the data that will be encountered in production. While it makes it easier to write accurate tests there are numerous downsides to running QA with production data.\"}),/*#__PURE__*/e(\"p\",{children:\"If you follow this practice you run the risk of running a test that may impact real customers. For example, you could run a test of an email notification process that sends real emails to end-users because you haven\u2019t properly masked or scrubbed the data being used. You also run the risk of exposing sensitive customer data unnecessarily. Again, in certain industries like healthcare and banking this isn\u2019t just a bad idea, it is illegal. Avoid testing with production data.\"}),/*#__PURE__*/e(\"h2\",{children:\"Environment Pollution: Unpatched, Insecure Testing Environments\"}),/*#__PURE__*/e(\"p\",{children:\"If your organization worries about security patches and tracking vulnerabilities in production you should have processes in place to run these patches on QA and Staging, and you should have an intentional approach to securing your QA and Staging environments in the same way that you protect production.\"}),/*#__PURE__*/e(\"p\",{children:\"This is important because you want to synchronize environment configuration to create more \u201Caccurate\u201D test environments, but it is also important because QA and staging environments are often an easy way for hackers to infiltrate an organization. Companies such as Google understand that developer laptops are a popular target for hackers because they are often one step away from loosely protected source code management, QA, and staging systems.\"}),/*#__PURE__*/e(\"h2\",{children:\"Environment Pollution: Out-of-date Testing Data Sets\"}),/*#__PURE__*/e(\"p\",{children:\"At the other end of the spectrum from organizations that test against production data are organizations that configure test environments with test data that is years out-of-date. Testing against ancient data is testing nothing at all. Production systems serving real customers generate patterns that need to be tested by test cases on non-production systems. This is especially true for large, public-facing web sites: users sign-up with uncommon names containing special characters and real users often configure applications in unanticipated ways.\"}),/*#__PURE__*/e(\"p\",{children:\"To create test environments that support accurate testing you should be running regular automated processes to copy and mask data from production. If you don\u2019t test with data sets similar to production you run the risk of creating more unused environments. With ancient data no one will trust your test environments, and tests run on these systems will be so unreliable no one will use these test environments.\"}),/*#__PURE__*/e(\"h2\",{children:\"Use Plutora to Track and Reduce Test Environment Pollution\"}),/*#__PURE__*/e(\"p\",{children:\"Plutora gives you the ability to track test environments across multiple projects and departments. You can keep track of environment churn and pollution and use Plutora as a way to identify unused environments or environment contention that often leads to dangerous, mixed environment testing practices.\"}),/*#__PURE__*/e(\"p\",{children:\"Plutora allows you to model the effort required to refresh testing data and gives you a valuable tool to govern and communicate across hundreds of test environment management customers. It is a tool to facilitate a more rational approach to environment management that encourages greater efficiency and less waste.\"}),/*#__PURE__*/e(\"p\",{children:\"Don\u2019t accept test environment pollution. Clean it up with Plutora.\"})]});export const richText7=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Managing databases and newer, more exotic NoSQL stores is an emerging challenge in an industry under constant pressure to move faster. While the industry has perfected the art of cloud-based provisioning and configuration of application servers, databases continue to be a pain point for environment managers.\"}),/*#__PURE__*/e(\"p\",{children:\"There are a few factors at play. Most large companies practicing software development are working with systems that have been operating for decades. When a bank throws a fancy, web-based interface on account management it doesn\u2019t always mean that the IT department performed an end-to-end rewrite of the entire system. Legacy account management systems and customer service infrastructure is often adapted to work with faster-moving front-end components that serve the website.\"}),/*#__PURE__*/e(\"p\",{children:\"Baremetal systems still power most of the largest businesses and NoSQL databases present new challenges that often back teams into a corner. Instead of creating QA and Staging environments to facilitate end-to-end testing, some test environment managers find themselves configuring QA and staging environments to point to production databases. This anti-pattern complicates environment management and it introduces risks when QA and production data is mixed.\"}),/*#__PURE__*/e(\"h2\",{children:\"Complicating Factor: Relational Databases are Still Prevalent and Difficult to Manage\"}),/*#__PURE__*/e(\"p\",{children:\"At Plutora, we see this pattern almost everywhere we go. Front-end web applications are using the latest tools and technologies while connecting to backend services that are running on baremetal services running relational databases. Large databases in the Fortune 500 are still centralized systems running Oracle or DB2. These databases are so valuable and so full of risk that they are still maintained by a team of dedicated DBAs who are more focused on manual operation and less interested in deployment automation or self-service tools for test environment management.\"}),/*#__PURE__*/e(\"p\",{children:\"If an organization doesn\u2019t invest in data masking technology or ways to automate the setup and teardown of relational databases test environment managers have no choice but to configure QA systems to point to production. DBAs often fall into a pattern of only worrying about production systems. To avoid this push your DBAs to take on more responsibility for automation and ask them to directly support test environment management activities.\"}),/*#__PURE__*/e(\"h2\",{children:\"Complicating Factor: Application Performance Tests Requires Data at Scale\"}),/*#__PURE__*/e(\"p\",{children:\"If your production system has a customer management database with 1 TB of data you can test functionality with a reduced data set of a few GBs, but you\u2019ll never be able to test the real performance of the application or the database. A database with terabytes of data is an entirely different beast than a database with only a few GBs. Query plans are going to be dramatically different depending on the size of various tables, and a DBA will have a completely different set of indexes to optimize and queries to analyze if your QA and Staging databases are several of orders of magnitude smaller than your production database.\"}),/*#__PURE__*/e(\"p\",{children:\"While it may be impractical to create multiple copies of a production database if your production database is very large you should strive to always create at least one performance testing copy of production that is properly masked. If management expects release managers to run performance tests or stress tests before releases having a copy of a production database will allow you to run these tests without having to create mixed test environments.\"}),/*#__PURE__*/e(\"h2\",{children:\"Complicating Factor: What to do about NoSQL or caching components?\"}),/*#__PURE__*/e(\"p\",{children:\"Maybe you use Cassandra or MongoDB? Maybe your site incorporates Couchbase as a caching layer? When you are trying to recreate the architecture and configuration of production NoSQL layers can be a complicating factor. Very often the data stored in NoSQL or caching components has some relationship to the data stored in an environment\u2019s database. While there are no direct \u201Cforeign key\u201D relationships that can be enforced across these different technologies, a test environment manager is still expected to ensure that these components are synchronized with the relational databases that continue to run most large applications.\"}),/*#__PURE__*/e(\"p\",{children:\"NoSQL and caching components are often easier to automate. It\u2019s synchronizing data across different data storage technologies that is the problem. To avoid having to test against production you should make sure that your DBAs and your developers agree on who has responsibility for these more \u201Cexotic\u201D forms of data storage. Very often your developers will take ownership of NoSQL data stores and incorporate them into configuration management and deployment automation scripts. As a test environment manager you need to make sure that someone owns the responsibility for setup and teardown.\"}),/*#__PURE__*/e(\"h2\",{children:\"Complicating Factor: No Good Answers for (Really) Big Data\"}),/*#__PURE__*/e(\"p\",{children:\"With the advent of petabyte-scale storage systems storing structured or unstructured data there is another complication \u2013 some data components of a complex architecture will never be duplicated to support QA or testing. You are not going to be able to test a QA or Staging system that interacts with petabytes of storing by copying this data. When it comes to Big Data, some of these testing exercises will need to be modeled against the realities of production. If you have petabytes (or exabytes) of data there may only be one system to test against: production.\"}),/*#__PURE__*/e(\"p\",{children:\"There\u2019s no good answer here for big data at scale. It may be unavoidable to create test environments that hit these gargantuan repositories of data. If you find yourself creating systems that need to be tested against these production data stores one way to ensure that a mixed test environment doesn\u2019t cause problems is to always make sure that your testing scripts are using read-only accounts.\"}),/*#__PURE__*/e(\"h2\",{children:\"Conclusion: Bring the DBAs into the Test Environment Conversation\"}),/*#__PURE__*/e(\"p\",{children:\"As I mentioned previously, DBAs are a job title that has remained relatively untouched by the DevOps and Agile revolutions. Most DBAs still practice the same job they practiced a decade ago, and it is an important, operations-oriented job focused on managing production risks.\"}),/*#__PURE__*/e(\"p\",{children:\"A DBAs job is often focused on one thing, and one thing only: keeping a production system up and running and making sure it performs well. This singular focus can make it difficult to attract their attention to the requirements of QA and Staging. Database and data quality issues are the reason why application development teams decide to forgo QA and Staging environments and just run critical tests in production. The best way to convince DBAs to participate in providing better data solutions for QA and Staging is to make the risks of testing against production known throughout the organization.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"If you use Plutora to track environment-related issues and release-related downtime you can make a direct connection between teams that test against production and teams that have adequate data to support QA and Staging.\"}),\" To start the conversation capture the risks related to testing in production and make these risks visible to your DBAs teams and to IT management. With the right focus on data and data quality test environment managers can find a way to avoid mixed test environments that mix QA resources with production.\"]})]});export const richText8=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"A pattern we\u2019re noticing more and more is that technology departments are starting to get out in front of the business. All too often this creates an odd paradox: the business might be asking technology to slow down because it hasn\u2019t adapted to a continuous delivery model. This is especially true in \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/plutora-necessary-air-traffic-control-increasingly-agile-enterprise\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"organizations that have fully adopted agile\"})}),\" and DevOps and who have adopted a more continuous approach to software delivery.\"]}),/*#__PURE__*/t(\"p\",{children:[\"A decade ago when the business was asking for a faster release cadence no one would have imagined that technology would have adapted to\",/*#__PURE__*/e(a,{href:\"https://www.usenix.org/conference/ures14/technical-sessions/presentation/going-3-week-daily-releases-netflix\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\" support a daily release cycle\"})}),\" or a release cycle even more frequent than that. We\u2019re seeing business stakeholders in some of the most mature DevOps organizations ask\\xa0developers to take a breather and step back from such an aggressive timeline. \",/*#__PURE__*/e(\"em\",{children:\"This points to a lack of infrastructure and management around continuous delivery pipelines.\"})]}),/*#__PURE__*/e(\"p\",{children:\"We solicited some feedback from some of our own clients to understand the pain points, and in this post, we\u2019re going to explore what you can do to get your own organization ready for a continuous delivery model.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"br\",{className:\"trailing-break\"})}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"As a \"}),/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/release-manager-job\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"strong\",{children:\"release manager\"})})}),/*#__PURE__*/e(\"strong\",{children:\", you understand that you sit at the center of the discussion between business and IT, and you're being asked to help answer the question, \u201CWhat do we do with all this new agility?\u201D\"})]}),/*#__PURE__*/e(\"p\",{children:\"Here are some of the common pushbacks and questions our customers are asking about the continuous delivery model:\"}),/*#__PURE__*/e(\"h2\",{children:\"\u201CIt was easier when we had a two-week release cycle.\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"We\u2019re seeing this more and more in the industry. Business stakeholders and VPs are lamenting the fact that with continuous delivery comes continuous responsibility.\"}),/*#__PURE__*/t(\"p\",{children:[\"They have to commit resources to an almost continuous series of releases and yearn for the old days of monthly or quarterly releases. Business stakeholders are noticing the increased workload that a more frequent release cycle brings and how that \",/*#__PURE__*/e(a,{href:\"https://www.infoq.com/articles/cd-benefits-challenges/\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"causes problems\"})}),\" for staff not yet ready to support continuous delivery. Other business stakeholders haven\u2019t adapted to the approach and miss the ceremony of a \u201Cbig, important\u201D release event.\"]}),/*#__PURE__*/t(\"p\",{children:[\"As a release manager, you can help people adapt to a continuous delivery model by sending out a release activity summary using the same cadence as the old release process. If you used to have a release every two weeks, you can use a dedicated release management solution like \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Plutora\"})}),\" to\",/*#__PURE__*/e(\"strong\",{children:\" generate a summary of release changes and release activity once every two weeks \"}),\"and send this to the business executives. \"]}),/*#__PURE__*/e(\"p\",{children:\"They\u2019ll appreciate the simplicity of the communication, and you can use it as an opportunity to drive home the fact that a continuous delivery model allows you\\xa0to move\\xa0faster with the same level of transparency.\"}),/*#__PURE__*/e(\"h2\",{children:\"\u201CI feel like we\u2019re sacrificing quality for agility.\u201D\"}),/*#__PURE__*/t(\"p\",{children:[\"If you hear this complaint your business stakeholders may have a point.\\xa0One of the biggest issues across all industries is \",/*#__PURE__*/e(a,{href:\"https://adtmag.com/articles/2012/10/31/qa-for-agile.aspx\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"quality assurance and automation.\\xa0\"})}),/*#__PURE__*/e(\"br\",{}),\"While we\u2019ve perfected the art of automation within a\\xa0continuous delivery model, our QA problems are still gated by resources.\"]}),/*#__PURE__*/e(\"p\",{children:\"Believe it or not, it's often more difficult to find a qualified QA tester than it is to find a great programmer. If you know what you're looking for, it's difficult to come across the right kind of QA testing resource because you're looking for a more specialized set of skills. If the business is complaining about quality sacrifices, they may be reacting to a perception that quality has suffered. If you're managing the continuous delivery process properly that perception will be a misperception. It's your job to correct it.\"}),/*#__PURE__*/e(\"p\",{children:\"Send your executives a record of how your releases are tested both before and after a release process. Some of these concerns may just be an attachment to the old QA \u201Cceremony.\u201D Our experience shows that it's best to address these concerns with data.\"}),/*#__PURE__*/t(\"p\",{children:[\"The best response\",/*#__PURE__*/e(\"strong\",{children:\"\\xa0makes\\xa0it clear that more frequent releases will result in far less risk \"}),\"while giving\\xa0your developers the ability to address problems in production more quickly than before.\"]}),/*#__PURE__*/e(\"h2\",{children:\"\u201CI don\u2019t even know what we\u2019re shipping and when?\u201D\"}),/*#__PURE__*/t(\"p\",{children:[\"This is a variation on \u201Cit was easier with a two-week release cycle.\u201D What you need to do here is make sure that your continuous delivery pipeline has the appropriate \",/*#__PURE__*/e(a,{href:\"https://en.wikipedia.org/wiki/Product_change_notification\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"change notification\"})}),\" sent to the appropriate stakeholders.\"]}),/*#__PURE__*/t(\"p\",{children:[\"This is where \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/release-management-raci-matrix\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Plutora\u2019s RACI matrix\"})}),\" comes in handy. If your executives don\u2019t feel communicated with about what\u2019s happening in a specific release, you need to make sure that the right people are on the \u201CI\u201D quadrant (informed) of this matrix.\"]}),/*#__PURE__*/e(\"p\",{children:\"Such a comment also\\xa0suggests that you need to take the time for each release to schedule meetings with affected business stakeholders. If you're not using a dedicated release management tool like Plutora, it's almost impossible to aggregate and understand the effective RACI matrix for a given release process. With Plutora we record all of this for you and give you a list of people who need to be informed about the release process.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"If you're embracing Agile and moving toward a more continuous delivery model across your organization, Plutora is one way to make sure that you keep your executives informed.\"})}),/*#__PURE__*/e(\"h2\",{children:\"\u201CContinuous Delivery seems risky. Who\u2019s making decisions about features?\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"When your releases are infrequent and more \u201Cceremonial.\u201D Business has a steady and predictable number of interaction points with IT. Product managers and business stakeholders can also think of the progression of a product in distinct cycles. Once every two weeks the business used to deliver a set of features and those features could be measured and reported upon.\"}),/*#__PURE__*/e(\"p\",{children:\"In the past, when the business end focused all efforts on a \u201Crelease,\u201D it wasn\u2019t thinking about individual features. This might have made it easier for the business to think about \u201Cwhat is going into the April release.\u201D\"}),/*#__PURE__*/e(\"p\",{children:'Now that you have a team of engineers ready to push code to production every single day, the business end needs to stop thinking about the\\xa0release \"event\" and start thinking about the product as a continuous progression of features. Product managers and project managers need to start thinking about \u201Cfeatures\u201D and stop thinking about \u201Creleases.'}),/*#__PURE__*/e(\"h2\",{children:\"Moving to a Continuous Delivery Model\"}),/*#__PURE__*/e(\"p\",{children:\"As you move to a more continuous delivery model, you should also be moving toward smaller, more independent release teams. These smaller teams will be delivering features to a very well defined portion of your application. After you make this transition you\u2019ll be able to create a report for the business that outlines changes to a specific portion of your application.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"With Plutora you\u2019ll be able to see everything assembled, in one place, no matter how many teams you're supporting. Request your Plutora demo \"}),/*#__PURE__*/e(a,{href:\"/evaluate-now\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"strong\",{children:\"here\"})})}),/*#__PURE__*/e(\"strong\",{children:\".\"})]})]});export const richText9=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"\u201CTo truly achieve IT delivery assurance, companies must empower program managers and delivery managers with a dedicated tool for introducing orchestrated, end-to-end control of the delivery process and visibility into project statuses, delivery progress and software quality across the entire organization.\u201D\"}),/*#__PURE__*/t(\"p\",{children:[\"For years, project management offices have gotten by with their \",/*#__PURE__*/e(a,{href:\"https://www.pmi.org/learning/featured-topics/portfolio\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"project portfolio management\"})}),\" (PPM) tools. However, times are changing and in the increasingly software-driven business world, these tools just aren\u2019t enough to handle the demands being put on delivery managers.\"]}),/*#__PURE__*/t(\"p\",{children:[\"If developers have a litany of tools to choose from and software testers can track test cases and manage defects with dedicated tools, project management teams should also have a dedicated tool to support rapid delivery. In our latest free whitepaper \u2014\\xa0\",/*#__PURE__*/e(a,{href:\"/resources/whitepapers/achieving-it-delivery-assurance\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"em\",{children:\"Achieving IT Delivery Assurance Through Effective Enterprise Release Management\"})})}),/*#__PURE__*/e(\"em\",{children:\"\\xa0\"}),\"\u2014 we explain the need for dedicated enterprise release management tools for project management teams.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Where Typical Approaches to Delivery Assurance Get Stuck\"}),/*#__PURE__*/t(\"p\",{children:[\"The general components of delivery processes are pretty universal, but one piece in particular causes challenges that are sparking the need for enterprise release management tools. The final stage, \\xa0where individual business requirement projects are dropped into the IT delivery factory for end-to-end coding and testing, is problematic under the demands of a modern enterprise.\",/*#__PURE__*/e(\"br\",{}),\"At this stage, the gap between high-level project managers and the lower-level developers and testers is most apparent. PPM tools have sufficed in unifying these two levels of the delivery assurance picture, but only because \",/*#__PURE__*/e(a,{href:\"https://stackoverflow.com/questions/3538286/is-frequency-of-release-the-only-real-difference-between-agile-and-waterfall\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"waterfall demands\"})}),\" have eased the strain between them. Now, the gap between each level is widening and there\u2019s no way for project managers to keep track of project statuses without ineffective (and costly) in-person meetings.\"]}),/*#__PURE__*/e(\"p\",{children:\"To avoid wasting money on ineffective meetings, implement a dedicated ERM solution for your project management team.\"}),/*#__PURE__*/e(\"h2\",{children:\"The 5 Tenets of IT Delivery Assurance and Their Impact on Visibility\"}),/*#__PURE__*/e(\"p\",{children:\"When it comes to achieving IT delivery assurance, the name of the game is visibility. Without a dedicated tool, project management teams have no way to see the entire software release landscape and, as a result, projects are delayed or flawed. When searching for an ERM solution, ensure your investment supports these 5 tenets of delivery assurance:\"}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"The Release Plan\"}),\": Bridge the gap between business demands and delivery processes.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Governance Gates\"}),\": Don\u2019t let agile development trump quality assurance.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"The Environment Plan\"}),\": Properly manage your finite test environment resources.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Deployment Management\"}),\": Keep each step of the deployment on schedule.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Quality Assurance\"}),\": Compile all testing data in a central location for improved visibility.\"]})})]}),/*#__PURE__*/t(\"p\",{children:[\"In \\xa0\",/*#__PURE__*/e(a,{href:\"/resources/whitepapers/achieving-it-delivery-assurance\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"em\",{children:\"Achieving IT Delivery Assurance Through Effective Enterprise Release Management\"})})}),\", you\u2019ll discover the differences between a project management life without visibility and one with a comprehensive perspective over the entire release portfolio \u2014 and learn how a dedicated project management tool satisfies each of the 5 tenets of delivery assurance.\"]})]});export const richText10=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"\u201CTo keep up with increasing demand for high quality, rapid software releases, IT organizations must shift to Disciplined DevOps \u2014 an approach to software release collaboration that blends agile delivery with risk management and governance that support delivery assurance\u201D\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://www.mavenwave.com/services/infrastructure/devops/\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"DevOps has become something of a buzzword\"})}),\" in the IT community as companies craft their own definitions to suit internal needs. However, the core values of agility and collaboration in software release processes permeate every iteration of DevOps. The only problem is that demand for faster and more frequent software releases is revealing glaring holes in many DevOps strategies.In the latest Plutora white paper, \",/*#__PURE__*/e(a,{href:\"/resources/whitepapers/disciplined-devops-risk-management-governance\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"em\",{children:\"Disciplined DevOps: Blending Agility with Risk Management & Governance\"})})}),\", we discuss the need to reign in some of the creative chaos in favor of a more disciplined approach to DevOps processes that creates\\xa0a level of control over the increasing volume of software releases.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Challenges of Undisciplined DevOps Processes\"}),/*#__PURE__*/e(\"p\",{children:\"While your business is constantly demanding greater speed in release cycles, it\u2019s often difficult to pinpoint the processes that are causing bottlenecks. With undisciplined DevOps processes, these are three common roadblocks to swift release cycles:\"}),/*#__PURE__*/e(\"ul\",{children:/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Siloed IT Professionals: \"}),\"Traditional IT teams naturally become siloed as practitioners specialize in certain pieces of the release process. These silos hinder collaboration and ultimately delay releases even though DevOps is supposed to streamline both.\"]})})}),/*#__PURE__*/e(\"ul\",{children:/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Operations Gets Lost in the Mix: \"}),\"The contention between rapid-fire development and the operations teams that value methodical quality assurance causes ops teams to become overwhelmed by release deadlines. More defects can slip into code when developers try to meet these deadlines and operations simply can\u2019t keep up using manual processes that aren\u2019t interoperable with developer tools.\"]})})}),/*#__PURE__*/e(\"ul\",{children:/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Focusing on Continuous Delivery Above All Else: \"}),\"Delivery isn\u2019t the only aspect of DevOps \u2014 but sometimes the demand for speed makes it seem like it is. Undisciplined DevOps teams will quickly see an increased risk of failure if delivery trumps focus on other key areas of the release cycle.\"]})})}),/*#__PURE__*/e(\"p\",{children:\"Establishing end-to-end governance gates can help you add a much-needed element of discipline to your DevOps processes and strategy, enabling greater successes in an\\xa0increasingly software-driven business world.\"}),/*#__PURE__*/e(\"h2\",{children:\"Enterprise Release Management \u2014 The Key to Bringing\\xa0Discipline to\\xa0DevOps\"}),/*#__PURE__*/t(\"p\",{children:[\"While DevOps ideology has sparked increased use of automated solutions for various IT teams, there hasn\u2019t been an answer to automation of the overarching delivery process. With an enterprise release management solution, you can \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"achieve insight\\xa0into your DevOps processes\"})}),\" that enables release managers to truly streamline development and QA.In the \",/*#__PURE__*/e(a,{href:\"/resources/whitepapers/disciplined-devops-risk-management-governance\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"em\",{children:\"Discipline DevOps: Blending Agility with Risk Management & Governance\"})})}),\" white paper, you\u2019ll discover what exactly disciplined DevOps really means, how it helps companies achieve the promise of DevOps despite increasing speed/volume demands and why enterprise release management is a necessary component to make it all a reality.\"]})]});export const richText11=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Two decades makes a huge difference for software developers. We\u2019ve gone from months-long development cycles to lifecycles measured in weeks or days, with some on the \u201Cbleeding edge\u201D executing\\xa0highly agile software releases even more frequently than that.\"}),/*#__PURE__*/t(\"p\",{children:[\"At Plutora, our management team has been at the forefront of this transformation for decades. We\u2019ve moved the largest organizations from quarterly releases to daily release cadences, and we\u2019ve seen everything that works and everything that doesn\u2019t. \",/*#__PURE__*/e(\"strong\",{children:\"Of all the factors that contribute to more agile software releases,\\xa0our own experience has taught us that transparency and communication make all the difference.\"})]}),/*#__PURE__*/t(\"p\",{children:[\"You can throw as many automation tools at a large enterprise as you want, but until release management has visibility you will not achieve greater agility. \",/*#__PURE__*/e(a,{href:\"https://www.activestate.com/blog/devops-tools-vs-culture/\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"DevOps is about communication\"})}),\".\"]}),/*#__PURE__*/t(\"p\",{children:[\"Without the appropriate management tools, attempts at greater agility turn into unmanageable anarchy and large organizations regress to earlier patterns of inefficiency. This is \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/company\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"why we created Plutora\"})}),\". Our SaaS solution\\xa0provides the structure for more agile software releases.\"]}),/*#__PURE__*/t(\"p\",{children:[\"Critical to the success of our efforts is the ability to accommodate\\xa0the realities of the modern enterprise by supporting newer, more nimble release models \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/continuous-delivery-with-legacy-software-systems\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"alongside slower-moving legacy projects\"})}),\". Our products are designed to\\xa0support your process, without\\xa0dictating adherence to a cookie-cutter approach to software development. It\u2019s your process, and we\u2019re only here to support it.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Moving Faster without Stumbling: Transparency and Communication\"}),/*#__PURE__*/e(\"p\",{children:\"If you want to move faster without stumbling and increasing the risks that accompany software releases, you need to focus on automation, quality, and a more detailed \u201Corchestration\u201D of release activities.\"}),/*#__PURE__*/t(\"p\",{children:[\"Detailed orchestration is Plutora's bread and butter. We\u2019ll help \",/*#__PURE__*/e(\"em\",{children:\"you\"}),\" track the responsibility and effort required for automation and quality initiatives, but it's \",/*#__PURE__*/e(\"em\",{children:\"our\"}),\" responsibility to systemically\\xa0identify what cues need to be delivered in what sequence to successfully orchestrate hundreds of actors in an efficient release process.\"]}),/*#__PURE__*/e(\"p\",{children:\"The \u201Cdetailed orchestration\u201D component of enterprise DevOps is under-appreciated because, when it works, it\u2019s the least noticeable aspect of DevOps.\"}),/*#__PURE__*/e(\"p\",{children:\"When you hear about\\xa0a large company adopting DevOps to speed up the delivery of software, these stories often tend to focus on technology \u2013 that is, tools. Specifically, you\u2019ll hear stories of individual developers using automation tools to create fully automated deployment scripts.\"}),/*#__PURE__*/e(\"p\",{children:\"This is the current picture of DevOps: these companies finally decided to let the developers have access to production-facing systems, and they were able to both cut out the \u201Cmiddle man\u201D and move faster. This tool-driven aspect of DevOps is important, but it isn\u2019t the full story.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/complexity-at-scale-trials-and-tribulations-of-success\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"At scale, these successes are only possible\"})}),\" when you have other tools that support a faster pace of software delivery. Unless you're working with one development team startup, DevOps needs some structure to succeed in a multi-billion dollar enterprise.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Automation Tools are Not Enough\"}),/*#__PURE__*/t(\"p\",{children:[\"In a large organization, an organization with thousands of developers, developer-enablement by itself doesn\u2019t create a more agile environment. \",/*#__PURE__*/e(\"strong\",{children:\"At scale you need structure\"}),\" \u2013 structure to support developers who find themselves in a position to automate.\"]}),/*#__PURE__*/e(\"p\",{children:\"You need a way to track the usage of cloud services, and, even when infrastructure is self-service, you need a window into how projects and developers are making use of these services.\"}),/*#__PURE__*/e(\"p\",{children:\"DevOps has transformed the way we deploy software, but the message of effortless, tool-driven simplicity can be misleading.\"}),/*#__PURE__*/t(\"p\",{children:[\"Through our work, we've been afforded a window into thousands of companies practicing DevOps, and we\u2019ve found a correlation between DevOps success and \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/the-secret-to-success-detailed-release-planning-preparation\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"a commitment to detailed release planning\"})}),\".\"]}),/*#__PURE__*/t(\"p\",{children:[\"Along with the capabilities introduced by tools like \",/*#__PURE__*/e(a,{href:\"https://puppet.com/devops/\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Puppet\"})}),\" and \",/*#__PURE__*/e(a,{href:\"https://www.chef.io/\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Chef\"})}),\", you also need tools to sequence releases and guarantee that your own staff isn\u2019t overwhelmed by the pace of automation.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Doing More with Less, Faster\u2026 Yesterday\"}),/*#__PURE__*/t(\"p\",{children:[\"Software is transforming businesses across all industries, and \",/*#__PURE__*/e(a,{href:\"https://by.dialexa.com/5-telling-signs-of-innovative-companies\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"the pace of both innovation and software delivery\"})}),\" has increased. If you work at a bank or an airline, your output is often measured in the number of application features \u201Cdelivered\u201D as well as more traditional metrics such as availability.\"]}),/*#__PURE__*/e(\"p\",{children:\"We\u2019re optimizing our organizations and the way that we think about software to minimize time-to-market and maximize developer productivity.\"}),/*#__PURE__*/e(\"p\",{children:\"Trends such as DevOps and cloud computing are focused on the dual goals of greater\\xa0\u201Cagility\u201D coupled with greater efficiency. Do more with less, and do it faster.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://blogs.wsj.com/cio/2015/10/23/cio-voices-starwoods-martha-poulter-on-teaching-teams-to-trust-data/\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Most CIOs and CTOs have adapted\"})}),\". If you go to any large organization you\u2019ll see that teams have been aligned with these trends. Every company we've interacted with in 2016 has a DevOps initiative.\"]}),/*#__PURE__*/e(\"p\",{children:\"Across all global regions and all markets the focus of the last several years has been one of accelerated development and delivery, and we\u2019re seeing evidence that organizations are moving faster as measured by the metrics collected by our customers.\"}),/*#__PURE__*/e(\"p\",{children:\"As part of our own commitment to agility and customer-focused innovation we regularly interact with our customers and we incorporate feedback into our development process immediately. If a customer experiences a bug or if a customer has a novel requirement our developers have the tools to understand and adapt to novel use cases.\"}),/*#__PURE__*/t(\"p\",{children:[\"Over 93% of \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/resources\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"our customers report\"})}),\" that Plutora enables a faster delivery cycle within one month of adoption. Within a single month our software starts paying for itself \u2013 the opportunity cost of inefficiency is reduced, and teams are able to focus on execution. The ability to measure this inefficiency in existing release processes yields immediate results. Just understanding where the bottlenecks are and being able to visualize them was enough to drive quick results.\"]}),/*#__PURE__*/e(\"h2\",{children:\"More Agile Software Releases: Just a Key's Turn Away\"}),/*#__PURE__*/e(\"p\",{children:\"Several months after adoption our customers tell us that they couldn\u2019t imagine conducting releases across multiple projects without Plutora, and in more than one customer we\u2019ve been told that Plutora \u201Cunlocked\u201D the organization.\"}),/*#__PURE__*/e(\"p\",{children:\"In one particular case a company was unable to make progress on critical business initiatives due to unmanageable interdependencies between projects. One project would release a new feature only to uncovered bugs in dependent systems requiring rework. Teams were deadlocked on environments, and at one point the entire QA team informed management that it would impossible to fully test a release prior to deploying in production due to environment shortages.\"}),/*#__PURE__*/e(\"p\",{children:\"Such\\xa0are the problems that plague the enterprise. The problems that make companies throw up their hands and give up on the idea of 100% uptime or 100% quality. When you operate at the largest scales the complications seem to grow exponentially because you have so many interactions and so many projects with varying requirements.\"}),/*#__PURE__*/t(\"p\",{children:[\"It can seem impossible, but we\u2019re here to tell you that it isn\u2019t. We\u2019ve identified some of \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/release-management-pain-points\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"the pain points\"})}),\" that accompany releases at scale, and we\u2019ve created \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"a tool that can help you address complexity and scale\"})}),\" through transparency and communication. If you are looking to \u201Cunlock\u201D your organization\u2019s potential the quickest way to do this is to start shining a light on your release management challenges with \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/evaluate-now\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Plutora\"})}),\".\"]})]});export const richText12=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"\u201CIn many real-world case studies, Plutora has resulted in returns exceeding 600%. A typical return is around 400% depending on the depth of using the products. Factoring\\xa0additional savings from Environment reclamation and reduction in capital spending on servers or Cloud Environments, ROI can balloon\\xa0to over 1000%.\u201D\"}),/*#__PURE__*/t(\"p\",{children:[\"Even as software release demands exceed the capacity of traditional \",/*#__PURE__*/e(a,{href:\"https://www.cio.com/article/2434640/7-ways-to-improve-your-software-release-management.html\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"manual management techniques\"})}),\", business decision makers must still make economics their chief concern when evaluating new products\u2014especially for enterprise release management where automated solutions haven\u2019t become mainstream.It\u2019s easy for product marketing teams to create blustery messages regarding ROI, but what\u2019s more valuable is an actual step-by-step breakdown of the value a solution offers. In our white paper, \",/*#__PURE__*/e(a,{href:\"https://go.plutora.com/roi-of-effective-release-management-lp-0\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"em\",{children:\"The ROI of Effective Release Management: Organizational Model and Financial Assumptions\"})})}),/*#__PURE__*/e(\"em\",{children:\",\"}),\"\\xa0we\\xa0offer a practical example to highlight the benefits of a dedicated Release Management solution.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Contextualizing the Benefits Through Financial Modeling\"}),/*#__PURE__*/e(\"p\",{children:\"The example given in the whitepaper is generic by design. It\\xa0extends from the simple arithmetic governing\\xa0a medium-sized team \u2014 with 60 different players involved in the software delivery lifecycle \u2014\\xa0completing 2 major releases and 2 minor releases each month.\"}),/*#__PURE__*/e(\"p\",{children:\"Owing to mitigated environment contentions, greater managerial efficiencies, and\\xa0fewer\\xa0testing outages, such a team could expect to achieve a Return on Investment\\xa0upwards of 290% after implementing a high quality, enterprise level Release Management solution.\"}),/*#__PURE__*/e(\"p\",{children:\"That's just the bottom line. The underlying quantification\\xa0methodology and starting point assumptions are covered in some depth within the whitepaper itself.\"}),/*#__PURE__*/e(\"p\",{children:\"The point here is for you to understand that, for even a\\xa0medium-sized enterprise release team, the savings are real and significant.\"}),/*#__PURE__*/e(\"h2\",{children:\"Enterprise Release Management: A Collaborative Affair\"}),/*#__PURE__*/e(\"p\",{children:\"While developers make up the majority of a release team, that aspect of the process is already heavily automated and increasingly agile. The management level of the release process, on the other hand, is where employees and businesses still have a lot of \\xa0room for improvement. Aside from the cost savings that a proven release management solution introduces, release and test environment managers enjoy granular benefits to their daily operations:\"}),/*#__PURE__*/e(\"ul\",{children:/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Release Managers can expect increased visibility to rapidly spot developing delays and structural insight to identify and correct\\xa0root causes before they become disruptive. \"})})}),/*#__PURE__*/e(\"ul\",{children:/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[\"Test Environment Managers can expect\\xa0to gain hyper-local insights that enable \",/*#__PURE__*/e(a,{href:\"https://www.linkedin.com/pulse/blog-series-establishing-running-effective-test-function-dainty\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"fast reactions to environment contention\"})}),\" before it becomes inhibitive.\"]})})}),/*#__PURE__*/t(\"p\",{children:[\"Want to learn more about the ROI of optimizing your Release Management processes? \",/*#__PURE__*/e(a,{href:\"https://hubs.ly/H02FmT60\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Download the white paper today\"})}),\" to see how you can automate and streamline the management layer of enterprise releases.\"]})]});export const richText13=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Test environment conflict is when two projects or two releases require access to the same testing resources at the same time. For a Test Environment Manager this might mean that two projects need to test against the same database or deploy to the same environment at the same time, and for a release manager this might also mean that projects require services from the same QA or release engineering team.\"}),/*#__PURE__*/e(\"p\",{children:\"Test environment conflict tends to delay every project in an IT portfolio at once as project schedules are interdependent and a delay in one part of the department can cause cascading schedule slippage. In the best case test environment conflicts happen rarely and teams plan far ahead, and in the worst case test environment conflict can paralyze an entire IT department.\"}),/*#__PURE__*/e(\"div\",{children:\"https://youtu.be/LICtNo-VTPI\"}),/*#__PURE__*/e(\"p\",{children:\"In this post I focus on some solutions to test environment conflict. I\u2019ve outlined some best practices that will allow you to avoid these conflicts in your organization.\"}),/*#__PURE__*/e(\"h2\",{children:\"Best Practice: Track Release Schedules in a Single, Consolidated Dashboard\"}),/*#__PURE__*/e(\"p\",{children:\"This is what Plutora provides. Tracking all of your projects in Plutora gives you the ability to create a single, consolidated release schedule. You can track the effort required for environment setup and teardown and you can gather information about prior releases so that you can learn from prior incidents of test environment conflict.\"}),/*#__PURE__*/e(\"p\",{children:\"When you have a single release schedule everyone is on the same page about the sequence of events. You can point both management and your own internal customers to this single, consolidated dashboard so they understand the larger picture. Without a single, consolidated dashboard you run the risk of miscommunication. If you track release schedules and project timelines in a series of disconnected Wiki pages or Excel spreadsheets these will grow inaccurate over time and you\u2019ll spend up to 20% of your time in meetings trying to reconcile different sources of truth.\"}),/*#__PURE__*/e(\"p\",{children:\"How can you avoid test environment conflict if you can\u2019t even agree on a single release schedule? Use Plutora and you\u2019ll fix that situation immediately. You\u2019ll avoid test environment conflict because everyone will have the same view of the release schedule.\"}),/*#__PURE__*/e(\"h2\",{children:\"Best Practice: Dedicate Test Environments to Important Projects\"}),/*#__PURE__*/e(\"p\",{children:\"The easiest way to get rid of test environment conflicts is to simply dedicate test environments to all of your important projects. If you are moving toward continuous delivery you are likely already doing this as projects that can be delivered at any time require dedicated test environments all the time.\"}),/*#__PURE__*/e(\"p\",{children:\"If you are moving to the cloud or if you are practicing agile you should consider maintaining dedicated QA and staging environments for all of your projects.\"}),/*#__PURE__*/e(\"h2\",{children:\"Best Practice: Measure each Project\u2019s Release Commitment Success Rate\"}),/*#__PURE__*/e(\"p\",{children:\"Every project and every manager has something like a \u201Cbatting average\u201D for success. When a project makes a scheduling commitment you need to have a tool that allows you to keep track of this and measure how early or late a project is when they are ultimately ready to deliver software to a QA or Staging environment.\"}),/*#__PURE__*/e(\"p\",{children:\"Every test environment manager understands the difference between what a project promises and what is ultimately delivered and test environment managers often take it upon themselves to adjust timeline commitments accordingly, but with Plutora you can start tracking this more accurately so that you can adjust your expectations on the project or person making a promise.\"}),/*#__PURE__*/e(\"p\",{children:\"If a project is regularly on time or beating a schedule you should plan accordingly. On the other hand if a project is continually missing a delivery date by weeks or months you need to be able to factor this into your environment assignments and plans. Plutora gives you this insight and allows you to slice and dice past release commitment data to calculate a \u201Cbatting average\u201D for each project. This will allow you to make informed adjustments to avoid test environment conflict.\"}),/*#__PURE__*/e(\"h2\",{children:\"Best Practice: Be Transparent with Your Customers\"}),/*#__PURE__*/e(\"p\",{children:\"Everyone should have access to immediate information about not only their project status but the status of other projects they depend on. With Plutora you can grant project managers and engineering leadership access to up-to-date dashboards that capture release-related timelines and risks without having to assemble this information into manual Wiki pages or Excel spreadsheets.\"}),/*#__PURE__*/e(\"p\",{children:\"If everyone is able to see release risks evolve in real-time you don\u2019t have to schedule meetings just to gather the data necessary to get an accurate picture, and you don\u2019t have to wait to tell teams that they need to make adjustments. With Plutora, everyone is looking at the same data and when it changes they can react quickly. If one project provides an update that a critical timeline is going to be missed this information can make its way to other projects immediately. This level of transparency makes release and project management more agile and more immediate.\"}),/*#__PURE__*/e(\"h2\",{children:\"Best Practice: Be a Conduit for Communication, Not a Bottleneck\"}),/*#__PURE__*/e(\"p\",{children:\"If you are a test environment manager or a release manager you\u2019ll understand that it\u2019s better to be a conduit for projects to communicate with one another than it is to be a bottleneck. In today\u2019s fast-moving environments you want to enable as much \u201Cpeer-to-peer\u201D communication between projects as possible. The transparency I discussed in the previous item is part of this, but having a single repository of information is another.\"}),/*#__PURE__*/e(\"p\",{children:\"With Plutora teams using disparate issue trackers or other systems to support planning can communicate with one another using a shared reference \u2013 a single source of truth. If a team needs to communicate with downstream dependencies it can use Plutora\u2019s RACI diagrams to understand who needs to be involved in any given conversation. Instead of scheduling a meeting to figure out who needs to be involved in the next meeting, just check Plutora and generate a report including all of the responsible parties from a combination of RACI matrices.\"}),/*#__PURE__*/e(\"p\",{children:\"If a project needs to communicate about a potential delay of test environment conflict they can leverage the tool to make sure the right people are involved in that conversation.\"}),/*#__PURE__*/e(\"h2\",{children:\"Best Practice: Justify Delays When Necessary\"}),/*#__PURE__*/e(\"p\",{children:\"This is mostly directed at test environment managers. If there is a test environment conflict that requires a delay you are often in the unfortunate position of informing entire projects or departments that their critical timelines are about to be missed. You can say \u201Cdon\u2019t kill the messenger\u201D all you want, but it\u2019s very likely that projects will come to see test environment managers as part of the problem. Over time this will lead to more conflict, and you\u2019ll start to be associated with the problems caused by other projects.\"}),/*#__PURE__*/e(\"p\",{children:\"If there is a test environment conflict you can use Plutora to make the reasons for this delay known to all. If another project is running late and consuming shared QA resources you\u2019ll be able to tell your project more about why a delay is necessary. If you don\u2019t have Plutora you end up having to give projects a story about why they can\u2019t proceed. Instead of doing that, why not provide them with data? They can then use this data to communicate with management. Without Plutora you\u2019ll just end up getting blamed for constant schedule slippage.\"}),/*#__PURE__*/e(\"h2\",{children:\"Best Practice: Ask for More Resources When Necessary\"}),/*#__PURE__*/e(\"p\",{children:\"If your organization is making a frequent habit of test environment conflict you should be asking for more resources. If you need more hardware or a larger quota on a public cloud, Plutora can supply you with the raw data you need to justify these asks. If you need more people to support release engineering and testing environment setup and teardown then Plutora is the tool that can supply this data.\"}),/*#__PURE__*/e(\"p\",{children:\"Don\u2019t just accept test environment conflict as something that has to happen. Strive to eradicate it from your department and use the metrics from Plutora to motivate management to give you the resources you need to succeed. In an ideal situation, a business understands that it can\u2019t expect to both accelerate development schedules and force teams to share scarce testing resources. Using Plutora you can move your organization closer to the ideal of having a dedicated test environment for each of your important projects.\"}),/*#__PURE__*/e(\"h2\",{children:\"Best Practice: Make Test Environment Conflict Everyone\u2019s Problem\"}),/*#__PURE__*/e(\"p\",{children:\"Test environment conflict is avoidable, and it is your job to help educate everyone to why it happens. In most organizations test environment conflict is the test environment manager\u2019s problem, and most people just assume that environment managers aren\u2019t planning ahead well enough to avoid it.\"}),/*#__PURE__*/e(\"p\",{children:\"As a test environment manager you understand the several competing factors that force you into unwinnable scenarios. You can either choose to allocate resources to one project or the other, and you are no stranger to being the brunt of blame when projects can\u2019t meet timelines. Don\u2019t just continue to operate in this mode, ask your internal customers to use Plutora and demand that they participate in these decisions as equals. If a project misses a deadline and forces you to change a release schedule use the tool to make it clear to your department that test environments are a shared responsibility.\"})]});export const richText14=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"em\",{children:\"This is the third\\xa0installment in a series on\\xa0hiring considerations within\\xa0a modern enterprise software\\xa0environment.\\xa0\"}),/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/the-definitive-hiring-guide-for-test-environment-managers\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:/*#__PURE__*/e(\"em\",{children:\"For the second\\xa0installment, click here\"})})}),/*#__PURE__*/e(\"em\",{children:\".\"})]}),/*#__PURE__*/e(\"p\",{children:\"An Enterprise Release Manager (ERM) is a new role in the enterprise and it is a by-product of several factors. First, enterprises continue to report larger portfolios with an increased number of smaller, more independent projects. At the same time more companies are decentralizing deployment and release responsibility to individual development teams. With more projects releasing software to production more frequently organizations are establishing a new level of IT release management: the Enterprise Release Manager.\"}),/*#__PURE__*/e(\"p\",{children:\"Multiply the number of releases by\\xa0the number of projects in a department times the number of departments. Then, factor in the number of individuals responsible for supporting software delivery and you\u2019ll quickly realize that releases often involve everyone coordinating on challenging schedules under impossible deadlines. The Enterprise Release Manager is there to ensure that an organization has the proper structures in place to allow the company to scale efficiently.\"}),/*#__PURE__*/e(\"h2\",{children:\"More Projects, More Releases: More Management\"}),/*#__PURE__*/e(\"p\",{children:\"When an organization only delivered one or two major software initiatives per quarter the idea of having multiple levels of release management made little sense. There was a lot of ceremony around the launch of these large, waterfall-based projects, but the release frequency was lower. Today we have large companies with hundreds of projects competing for limited \u201Crunway\u201D space in the form of testing environments and production support resources. To use an airport analogy application release managers are the gate agents while Enterprise Release Managers keep track of the entire terminal (and your organization\u2019s release schedule may start to remind you of a flight status display at O\u2019Hare during a thunderstorm.)\"}),/*#__PURE__*/e(\"p\",{children:\"Today, some organizations deliver one or two major software initiatives every week (or every day.) Couple this with faster, more self-service releases and your organization needs someone focused on release coordination and alignment across multiple departments.\"}),/*#__PURE__*/e(\"h2\",{children:\"Enterprise Release Manager Job Description\"}),/*#__PURE__*/e(\"p\",{children:\"Here\u2019s what we would list if we were currently seeking the right candidate for an Enterprise Release Manager position:\"}),/*#__PURE__*/e(\"p\",{children:\"Seeking a senior project management professional with a focus on coordinating release activities across an entire enterprise portfolio. This role would involve coordination across multiple departments and the oversight of several application release managers each focused on a subsystem or collection of applications. This Enterprise Release Manager position is responsible for tracking and sequencing releases across the entire organization. This role will also focus on risk mitigation of release-related risks and conflict resolution between projects requesting access to limited production support and release engineering resources.\"}),/*#__PURE__*/e(\"p\",{children:\"Ideal candidates will have demonstrated an ability to communicate status of software delivery efforts to senior management along with a capacity to manage and track activities across multiple departments and development teams. Candidates with experience across both software development management and application release management are encouraged to apply for this executive-facing position.\"}),/*#__PURE__*/e(\"p\",{children:\"This position requires experience modeling resource demands across departments and establishing company-wide KPIs to measure release related activities.\"}),/*#__PURE__*/e(\"p\",{children:\"This management level position provides visibility to senior management for release-related activities across the entire portfolio, and this job description strikes the right balance between recruiting a senior project manager and someone seeking a director-level position. Your goal in recruiting an Enterprise Release Manager is to find an individual somewhere between a senior manager and a director. You\u2019ll also want someone with established management experience as the Enterprise Release Manager will often be presenting to C-level executives who are focused on software delivery.\"}),/*#__PURE__*/e(\"h2\",{children:\"Roles and Responsibilities\"}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Developing common strategies for release governance across multiple departments\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Facilitating cross-department coordination of release management functions\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Tracking an enterprise-wide release calendar\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Informing senior management of enterprise-wide exposure to release risk\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Mitigation of enterprise-wide release risk\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Measuring release cadence and effectiveness using common metrics across entire software portfolio\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Creating common standards and formats for release playbooks and working with production control to standardize release decision-making\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Defining common mechanisms for rollback and standards for capturing release-related performance indicators.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Forecasting demand for release resources and identifying opportunities for greater efficiency across the enterprise\"})})]}),/*#__PURE__*/e(\"h2\",{children:\"What Skills to Look for When Hiring an Enterprise Release Manager?\"}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Management is a critical skill for an Enterprise Release Manager. Individuals operating in this role won\u2019t be focused on the details of individual releases; instead they will be focused on the overall trends across multiple development teams.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Communication is another critical skill. An Enterprise Release Manager is setting the overall environment for release management and governance as such they need to be able to communicate with both management and individual application teams to create an environment where teams understand the shared vision for releases across the enterprise.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"The ability to identify and eliminate redundancies at the portfolio level. An Enterprise Release Manager is there to recognize patterns and opportunities for improvement throughout the entire organization. As more organizations adopt self-service deployments and releases it is the Enterprise Release Manager who ensures that this movement toward self-service doesn\u2019t result in confusion.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"The capacity to understand multi-level failure scenarios that can result from release activities. Enterprise Release Managers are the high-level referees for release activities and an ERM will get pulled into discussions surrounding release-related downtime and risk.\"})})]}),/*#__PURE__*/e(\"h2\",{children:\"Who is the Ideal Candidate?\"}),/*#__PURE__*/e(\"p\",{children:\"An Enterprise Release Manager is a senior resource on the boundary between mid-level project management and IT management. Depending on your technology strategy the role may also involve high-level decisions related to enterprise-wide strategies for DevOps and deployment. Look for someone who can interact with managers at the Director level and above.\"}),/*#__PURE__*/e(\"p\",{children:\"Seek out a candidate who can connect with the work effort involved in releases. This doesn\u2019t mean that they could conduct a release by themselves, but in any technical organization it\u2019s a good decision to make sure that managers understand the technologies they are managing. Today\u2019s release engineers and developers will quickly lose confident in a manager who doesn\u2019t understand the basics. Look for some awareness of technologies: what are the differences between a VM and a container? What are the defining characteristics of Java or .NET applications? Awareness is key, but detailed knowledge isn\u2019t necessary.\"}),/*#__PURE__*/e(\"p\",{children:\"The ideal candidate would be an experienced application release manager who has a track record of being a communicator and a coordinator. If an application release manager\u2019s job is to facilitate communication and avoid conflict between a single project and it\u2019s dependencies - an Enterprise Release Manager\u2019s job is to identify the conditions that could lead to conflict and make strategic decisions to avoid conflict. An application release manager plays a constant game of chess to ensure that a single project is delivered on time, and an Enterprise Release Manager has the ability to change the rules of the game. Find someone who can think strategically.\"}),/*#__PURE__*/e(\"h2\",{children:\"Who Not to Hire\"}),/*#__PURE__*/e(\"p\",{children:\"At the largest organization your Enterprise Release Manager is a manager of other application release managers. Don\u2019t hire someone who believes that an entire organization can be \u201Cshoe-horned\u201D into a single release process or a single software development lifecycle. In a decentralized organization there is a need for centralized governance, but there is also a mandate for teams to achieve some level of independence. Don\u2019t hire a resource who sees enterprise release management as a \u201Cone-way\u201D conversation focused on governance. Find a candidate who can bridge the gaps in an organization and who knows how to use portfolio-level policy to act as a change agent over time.\"}),/*#__PURE__*/e(\"p\",{children:\"Since this role is still developing there are going to be variations on the requirements and approaches to enterprise release management. Take this post as a suggestion, but always think about the unique characteristics of your organization and hire accordingly. Over the next decade you\u2019ll find that the Enterprise Release Manager or the managers that excel at enterprise release management are going to be the people that get promoted. The high-level governance of releases and the coordination between multiple groups in an increasingly self-service enterprise are the competitive advantages that are starting to differentiate top performers from everyone else.\"})]});export const richText15=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Your IT team has adopted DevOps approaches to enable \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/3-devops-considerations-for-the-enterprise\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"a faster and more reliable way\"})}),\" to move initiatives between development teams and operations. However, you\u2019re still witnessing inconsistent results despite a concerted effort to move towards continuous delivery. Why? Automating various steps of the application development process makes life easier for players in the various stages of application development and transition, but there\u2019s one piece that is often overlooked\u2014the glue that brings everything together\u2014enterprise release management.\"]}),/*#__PURE__*/e(\"p\",{children:\"If you want to help your organization achieve true agility through DevOps, it\u2019s critical that you facilitate the shift in perspective from release management as an endpoint to release management as a consistent end-to-end process. To do so, you have to strengthen your enterprise release management process.\"}),/*#__PURE__*/e(\"h2\",{children:\"Getting Enterprise Release Management Up to Speed: 8 Best Practices\"}),/*#__PURE__*/e(\"p\",{children:\"You might be getting by with your complex spreadsheets and manual enterprise release management strategies for now, but your application portfolio will quickly outgrow these practices. Insatiable business demand, interdependent applications and distributed delivery team results means existing ways of managing releases are guaranteed to fail. Check out these 8 best practices to strengthen your critical release management function:\"}),/*#__PURE__*/t(\"ol\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Review Your Existing Process:\"}),\"This is more than just questioning why manually managing changes with spreadsheets isn\u2019t a scalable approach. You must examine the team you\u2019ve assembled and the tools you\u2019ve provided them with. Improving release management requires more efficient, automated tools and teams willing to break down siloed organizational structures.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Clearly Define Release Cycles:\"}),\" Increasing business pressure to constantly improve applications is forcing faster release cycles. Define whether you want to update every day, week or month, and use past cycles to learn for the future.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Invest in the Right Release Management Team:\"}),\" Modern release management isn\u2019t a job for one Director to take on alone. \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/the-definitive-hiring-guide-for-test-environment-managers\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Create a team\"})}),\" that consists of release, environment, test and implementation managers. These players need strong collaborators as they work across multiple functions and teams.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Stay Ahead of the Planning Game:\"}),\" You might not know exactly which new features you\u2019ll have to implement one year from now, but you should know when that release cycle will happen. Getting out ahead of the release schedule keeps you on a consistent track for feature changes. Define the release cadence for each of the different types of applications in your portfolio.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Prioritize Based on Stakeholder Requests:\"}),\" Consistent release management provides a concrete base of information regarding which feature change your stakeholders want or need most. When releases only came once per month or quarter, feature prioritization was easy. Now it\u2019s a much more difficult process that must be automated if you have any hope of pleasing stakeholders with successful changes.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Make Your Pre-Production Environment a Priority:\"}),\" Speeding up your release cycles shouldn\u2019t mean you take shortcuts, such as skating through pre-production testing. Bottlenecks in hardware, storage, network connections, bandwidth, etc. can be spotted in the pre-production environment to avoid costly release issues. However, the more complex your portfolio becomes, the harder it will be to manually attend each release\u2019s pre-production environment.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Gain Control Through All Release Stages:\"}),\" The change process requires the physical transfer of build packages between development teams from testing through validation. Understanding each package delivery with a transparent view of the entire release process can help cut down on re-work that inevitably delays rollout. \",/*#__PURE__*/e(a,{href:\"https://www.slideshare.net/AmazonWebServices/modern-it-governance-through-transparency-and-automation\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Automate the governance\"})}),\" between the various phases of delivery.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"There\u2019s No Such Thing as Too Much Communication:\"}),\" Leave your siloed release management function behind. When you give every stakeholder in the release management process access to critical information, you can create a systematic way for stakeholders to see critical information in real-time. Real-time updates are essential for Directors of Release Management who are trying to maintain an increasingly complex portfolio of changes./li>\"]})})]}),/*#__PURE__*/e(\"p\",{children:\"In short, strengthening your release management function can\u2019t just be a matter of optimizing your spreadsheet approach. The typical manual spreadsheet strategy doesn\u2019t enable metric analysis or efficient prioritization\u2014two critical factors when speeding up the release management process. The need for a release management solution is becoming increasingly clear.\"})]});\nexport const __FramerMetadata__ = {\"exports\":{\"richText6\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText10\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText15\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText3\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText13\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText11\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText1\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText9\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText2\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText12\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText8\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText5\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText4\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText7\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText14\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}"],
  "mappings": "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",
  "names": ["richText", "u", "x", "p", "Link", "richText1", "richText2", "richText3", "richText4", "richText5", "richText6", "richText7", "richText8", "richText9", "richText10", "richText11", "richText12", "richText13", "richText14", "richText15", "__FramerMetadata__"]
}