{
  "version": 3,
  "sources": ["ssg:https://framerusercontent.com/modules/wQkrKbJZUqK24WDRABya/9JJSd55kUCD7308oVHah/VttwVM63r-32.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__*/e(\"p\",{children:\"Years and years, decades: that\u2019s how long some of the release processes we support have been running. In a sector that is so focused on the newest technologies it can be challenging to design systems that last more than a few years, but when you support software development at the largest scale you notice something: software changes, teams change, management changes, but one thing almost always remains constant \u2013 your release process.\"}),/*#__PURE__*/e(\"p\",{children:\"Your release process is the governance structure\\xa0that the organization has\\xa0set up to organize and collaborate together.\\xa0And, once you establish these patterns they are difficult to change.\"}),/*#__PURE__*/e(\"h2\",{children:\"Release Processes are Governance\"}),/*#__PURE__*/e(\"p\",{children:\"A release process is half technology and half governance, and the mechanism that teams use to validate, promote, and deploy systems to production \u2013 this is the pulse of the organization.\\xa0\\xa0 The contracts different teams develop over the years, and the processes designed to preserve uptime and reduce conflict all of that is governance, and when you decide to make a change to these processes it\u2019s almost like you have to convince a department to start a revolution.\"}),/*#__PURE__*/e(\"p\",{children:\"When you stand up in a meeting an announce that you are shuffling off the reins of an oppressive release process there will be a few people in the room who will secretly want to preserve this system.\\xa0 You\u2019ll need to have a tool at the ready to help identify inefficiency and support the transformation to a leaner, more efficient software organization, and you'll need allies along the way.\"}),/*#__PURE__*/e(\"h2\",{children:\"Don\u2019t Blunder into a Revolution: Conspire\"}),/*#__PURE__*/e(\"p\",{children:\"When it comes to planning a revolution, there\u2019s only one verb to use: \u201Cconspire.\u201D What\u2019s the definition?\"}),/*#__PURE__*/e(\"p\",{children:\"\u201Cmake secret plans jointly to commit an unlawful act\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"Don\u2019t worry.\\xa0 When you change your release process and make it more efficient and when you start granting exceptions for more Agile projects no one will be \u201Charmed,\u201D but many will see this change as \u201Cunlawful\u201D and somewhat dangerous.\\xa0 You\u2019ll be met with responses like, \u201CWe can\u2019t let that team release whenever they want to.\u201D But, in some organizations there's no way to move forward unless some of the unnecessary checkpoints and meetings are cancelled.\"}),/*#__PURE__*/t(\"p\",{children:[\"Across all industries we've been running heavy, process-oriented releases in an effort to mitigate release risk, and we're still operating some of the largest releases with processes developed in the 90s. \\xa0 Plutora was created because there has to be a better way. \\xa0Instead of assembling release status from spreadsheets a release manager should be able to mine the several systems the organization has stood up to track software progress. Teams should be enabled and empowered to move faster without having to sit through mindless process meetings that were created before tools like BMC and Jira had APIs or even existed. \",/*#__PURE__*/e(\"strong\",{children:\"\\xa0It's time to upgrade our approach to release processes and Plutora is that upgrade.\"})]}),/*#__PURE__*/e(\"p\",{children:\"To change a release process the first step is to identify who in your organization is thinking the same thing.\\xa0 Which projects will gladly serve as internal champions and how do you make progress visible to management (Hint: Use Plutora to track releases.)\"})]});export const richText1=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"If you work in a large enterprise you know what I\u2019m talking about. Some teams move fast (maybe too fast) while other teams still operate as if they are in 1985. How do you get these teams to move faster?\"}),/*#__PURE__*/e(\"p\",{children:\"There\u2019s such a wide range of capabilities in today\u2019s enterprise it can often feel like you are dealing with multiple departments within a single IT department. One team might take months to gather requirements before coding, while another team might be making a release to production every few hours. The slow-moving IT department of the late 90s has been replaced by a patchwork of different approaches to software delivery, and it can present a challenge to the professionals tasked with making sense of releases across multiple teams.\"}),/*#__PURE__*/e(\"p\",{children:\"While Agile increased the release cadence for most teams every large IT department still has that one team that will tell you it might take 6 months to get a new data environment configured. Alternatively you might be dealing with a business that has grown comfortable with slow moving releases \u2013 a business that doesn\u2019t understand that more frequent software releases can often lead to less risk and dramatically lower overhead.\"}),/*#__PURE__*/e(\"p\",{children:\"Teams that move slowly make it difficult to synchronize multi-project release timelines and they force teams ready to move faster to stop and wait for numerous release checkpoints. The mandate today is to move faster, and the responsibility of motivating teams to move faster often falls on release management. Some teams don\u2019t need any motivation to move faster, but teams working on traditionally slow moving technologies might be holding on to that legacy mindset that software development moves slowly.\"}),/*#__PURE__*/e(\"p\",{children:\"It doesn\u2019t hurt to give projects some motivation to move faster. Otherwise you could find yourself supporting projects that hold all the others back. Here are some strategies to motivate those unwilling \u201Claggards\u201D:\"}),/*#__PURE__*/e(\"h2\",{children:\"Motivation #1: Comparative Metrics\"}),/*#__PURE__*/e(\"p\",{children:\"\u201CYou know what? Other groups don\u2019t take a week to get through QA. I\u2019d really like to get software to market faster. Can you tell me what you need to move faster?\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"With Plutora you can create a report that identifies the projects that are taking the longest to deliver and consuming the most release-related resources such as QA and release management. If you do nothing else, calculate how much it costs in terms of time dedicated to qualify a release and write a report that compares projects to one another.\"}),/*#__PURE__*/e(\"p\",{children:\"Some healthy competition within an IT department is always a good idea especially when you have such a wide range of approaches. In my own experience managing complex release processes there\u2019s always room for improvement. Drawing contrasts between groups is a good way to identify inefficiency and prove to skeptical projects that more agility isn\u2019t only possible, it\u2019s already in the department.\"}),/*#__PURE__*/e(\"p\",{children:\"What you\u2019ll find is that the teams with the most excuses to stay with infrequent release cadences are often the teams that increase the costs associated with release management and introduce release-related downtime.\"}),/*#__PURE__*/e(\"h2\",{children:\"Motivation #2: Give them a Nudge\"}),/*#__PURE__*/e(\"p\",{children:\"\u201CWe\u2019re doubling your release cadence next month. Even if you need to cut your release plan in half, I want to see results show up in production faster.\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"Release management can often be pushed around by the projects it supports. Depending on the level of support release management receives from IT management you might be able to turn the tables, and establish a maximum time between deployments in order to minimize the risk of larger, infrequent deployments. An \u201Call projects must have a monthly release to production to minimize release risks\u201D strategy often works, and you can use risk reduction as a goal.\"}),/*#__PURE__*/e(\"p\",{children:\"Here\u2019s the logic. When a project waits months between releases it stores up change-related risk especially if it is surrounded by a \u201Csea\u201D of faster moving projects. If you only release your core production systems to production once every three months then you don\u2019t have the same level of experience supporting production and your changes are full of high-level, strategic changes that tend to introduce downtime.\"}),/*#__PURE__*/e(\"p\",{children:\"If you have a project that is used to releasing every month or even longer tell this project that they are going to be transitioning to a monthly or weekly release cycle.\"}),/*#__PURE__*/e(\"h2\",{children:\"Motivation #3: Remove the Excuse \u2013 Divide and Conquer\"}),/*#__PURE__*/e(\"p\",{children:\"\u201CYour releases are too risky because the system you\u2019ve created is monolithic. I\u2019m going to split up the project into a front-end and back-end component and I want each team to be able to release independently.\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"This is the most common anti-pattern in the industry. Despite the myriad ways in which enterprise architectures can be decoupled we still have developers and architects creating monolithic systems throughout the industry. What\u2019s more surprising is that many people working on SOA architectures still don\u2019t fully understand how highly coupled service architectures can be when years of bad decision making is compounded.\"}),/*#__PURE__*/e(\"p\",{children:\"If your teams have to perform a \u201CBig Bang\u201D release because they haven\u2019t decoupled systems from one another you should provide them with some motivation to do so. Break up monolithic systems into multiple components and define API interfaces across these boundaries. Sit down with teams and get them to think of themselves as independent entities. Some organizations even go as far as forcing independent teams to consider themselves wholly independent companies. You don\u2019t have to go that far, but splitting up a monolith is often the fastest way to achieve more agile releases.\"}),/*#__PURE__*/e(\"h2\",{children:\"Motivation #4: Ask them Participate in Frequent Release Process\"}),/*#__PURE__*/e(\"p\",{children:\"\u201CI know you only release your systems to production twice a year, but as part of our new efforts to align release management across the department I\u2019m going to ask your teams to start participating in the weekly release process.\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"Exposing your slow-moving teams to your agile teams will have two effects. First it will show them that there is a way to accelerate development, and second it will give people on these slow-moving teams a change to engage with other, more agile teams. Agile releases and the possibilities of DevOps are infectious within an organization. If you ask teams to monitor the weekly release process, over time they will understand what it takes to transition to this process.\"}),/*#__PURE__*/e(\"p\",{children:\"They will understand that a weekly release cadence is a different approach to releases altogether. They involve lower-ceremony meetings, shorter QA cycles, and fewer release milestones. When your slower-moving teams start to see what it looks like they see what it is going to take to prepare for greater agility.\"}),/*#__PURE__*/e(\"h2\",{children:\"Plutora as a Valuable Management Tool\"}),/*#__PURE__*/e(\"p\",{children:\"You can use Plutora to send all of these signals to your slower-moving teams. It creates compelling reports that present data across all projects and teams can use it as a tool to track efforts toward a more agile approach to releases. One of the most valuable motivation tools is simple transparency \u2013 having a single source of truth for a release timeline that can illustrate just how long it takes some projects to navigate challenging environment and release management issues.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://www.plutora.com/evaluate-now\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Start using Plutora now\"})}),\" and your projects will start to pick up the pace.\"]})]});export const richText2=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Most large software enterprises are facing a tough choice: on one hand you have the control and stability of traditional ITSM, and on the other you have the self-service freedom and agility of more modern approaches such as DevOps.\\xa0 \\xa0As organizations move toward self-service releases and more rapid iterations \",/*#__PURE__*/e(\"em\",{children:\"change management presents a problematic bottleneck for teams looking to move quickly\"}),\".\"]}),/*#__PURE__*/e(\"p\",{children:\"In this post I discuss an example from one of our customers and how they\u2019ve used Plutora to change the way change management works to adapt to an increasingly agile reality.\"}),/*#__PURE__*/t(\"p\",{children:[\"A few months ago I was walking one of our customers through Plutora\u2019s ability to model governance gates in a release.\\xa0 Our tool gives a release manager the ability to define checkpoints during a release cycle.\\xa0 For example, a project may require formal sign-off from QA in order to proceed, or a release may need \",/*#__PURE__*/e(\"em\",{children:\"explicit approval\"}),\" from a specific manager in a change request filed in BMC Remedy.\\xa0 This is the reality in most large companies \u2013 you can be on a conference call with 50 people, everyone is ready to go, but the whole team has to wait for someone to click on the \u201CApprove\u201D button.\\xa0 Governance gates are very real for large systems, and they\u2019ve traditionally had a strong \u201Cpadlock\u201D on production deployments.\"]}),/*#__PURE__*/e(\"h2\",{children:\"\u201CTrue Believers\u201D in Change Control\"}),/*#__PURE__*/e(\"p\",{children:\"This customer is a \u201Ctrue believer\u201D in change control.\\xa0 I use the word \u201Cbeliever\u201D on purpose.\\xa0 When it comes to change control you have two groups: people who view it as a laborious, often unnecessary process, and people who believe it to be an essential control over the chaos of software development.\"}),/*#__PURE__*/e(\"p\",{children:\"To a true believer Change Management is required for any change to a production-facing system.\\xa0 No matter how small, any change has to have a Change Request (CRQ) in BMC\u2019s Remedy Change Management System (CMS).\\xa0 This change must have an accurate assessment of the level of risk, a detailed accounting of systems impacted, and a long audit trail of approvals.\"}),/*#__PURE__*/e(\"h2\",{children:\"The Overriding Imperative: Move Faster\u2026 Yesterday\"}),/*#__PURE__*/e(\"p\",{children:\"While we were discussing his organization\u2019s change control process he said something interesting:\"}),/*#__PURE__*/e(\"p\",{children:\"\u201CIt isn\u2019t like someone couldn\u2019t just skip the CRQ and deploy directly production.\\xa0 Unfortunately, this is happening all the time with our new DevOps teams. We\u2019re trying to figure out how to unblock teams but still maintain control.\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"What struck me was the contrast between his organization\u2019s commitments to change management.\\xa0 His is the kind of company that manages real release risk, and his change management team is admitting that the existing approaches to change management don\u2019t work.\\xa0 They don\u2019t align with DevOps or agile, and then breakdown as teams accelerate toward weekly and daily release cycles.\"}),/*#__PURE__*/e(\"h2\",{children:\"Your Daily Release Needs to be Submitted to the CAB Four Days in Advance?\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"While most of his projects continue to follow the established process, \"}),/*#__PURE__*/e(\"em\",{children:/*#__PURE__*/e(\"strong\",{children:\"he\u2019s in the process of perfecting a new approach to change management that puts the emphasis on accountability over control.\"})}),/*#__PURE__*/e(\"strong\",{children:\"\\xa0\\xa0 Plutora\u2019s a part of this solution.\"})]}),/*#__PURE__*/e(\"p\",{children:\"With the introduction of DevOps operational responsibility has been shifted to individual teams.\\xa0\\xa0 Teams have the ability to push releases to production directly.\\xa0 In the past, this would have been unheard of.\\xa0 Development teams would have thrown software over the wall that separates development and operations and the process of verifying and approving the release would begin \u2013 this was back when software was released once every two months so change control had days of lead time to discuss an upcoming release.\"}),/*#__PURE__*/e(\"p\",{children:\"As teams assumed more responsibility and as timelines accelerated change management was quickly becoming overwhelmed with requests from frustrated development groups.\\xa0\\xa0 In one example, a team was ready to deploy to production every single day.\\xa0 Even though they were ready for a daily release cadence, change control continued to insist on four days of notice for each release.\\xa0\\xa0 Management stepped in and told change management to move faster.\"}),/*#__PURE__*/e(\"h2\",{children:\"Unlock the Gates, Get Some Warning Signs, and Install Cameras\"}),/*#__PURE__*/e(\"p\",{children:\"This customer\u2019s solution was more freedom coupled with greater accountability. If teams want to deploy as quickly as they can write code, let them do so and design systems that let change management hold teams accountable for compliance and quality.\\xa0 Let developers move as fast as they need to and automate the creation of CRQs from change sets generated by developer-facing tools.\"}),/*#__PURE__*/e(\"p\",{children:\"Instead of presenting developers with a locked governance gate he\u2019s removed the padlock and installed some serious warning signs telling teams that production deployments are monitored and audited by change management.\\xa0 Has some bad code made its way into production since the change?\\xa0 Yes, but he\u2019s also realized that bad code was making it past his group in the past.\\xa0 The difference now is that he\u2019s used more automation to create more accurate CRQs when in the past he\u2019d rely on developers to tell him what was in a release.\"}),/*#__PURE__*/e(\"h2\",{children:\"Plutora\u2019s Automation Changes Change Management\"}),/*#__PURE__*/e(\"p\",{children:\"Plutora supports this process by automating the creation of a CRQ in Remedy from systems like JIRA.\\xa0 When one of his development teams is ready to run a release they can trigger the CRQ creation at the click of a button and his department is immediately made aware of the risk level and the changes involved in a release.\"}),/*#__PURE__*/e(\"p\",{children:\"Developers are warned about the process and the necessary approvals ahead of time, and detailed records are kept of which teams pushed what changes when.\\xa0 If a team is consistently introducing bugs into production or if a team is a constant source of change-related downtime.\\xa0 His group is now responsible for tracking changes and holding teams accountable.\\xa0 There are still some high-profile systems requiring a full signoff that won\u2019t be automated in the short-term, but many of his teams are transitioning to this new model.\"}),/*#__PURE__*/e(\"p\",{children:\"Moving from a command-and-control paradigm for change manage toward a more decentralized approach while preserving the ability to manage change is something that all industries will need to do as software delivery accelerates.\\xa0 Plutora is designed to support both the existing, locked governance gates alongside newer models that emphasize agile accountability.\\xa0 It provides this support because we\u2019ve designed it to integrate with just about everything.\"})]});export const richText3=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" is a trend identified by Gartner that describes a common challenge for IT departments \u2013 how to support two modes of operation within the same IT department.\\xa0\\xa0 According to \",/*#__PURE__*/e(a,{href:\"https://www.gartner.com/it-glossary/bimodal\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Gartner\u2019s definition\"})}),\":\u201CMode 1 is traditional and sequential, emphasizing safety and accuracy. Mode 2 is exploratory and nonlinear, emphasizing agility and speed.\u201D\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" is an accurate picture of the current reality of the IT department, but it's often impossible to fully isolate both modes when it comes to releases. \\xa0When you release software to production you are integrating systems across both modes. \\xa0Release managers sit at the boundary between these two modes and are often responsible for managing scheduling and resource conflicts between Mode 1 and Mode 2 projects.Here are just some of the ways Plutora is designed to support enterprise release management across Mode 1 and Mode 2 projects in a \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" department:\"]}),/*#__PURE__*/e(\"h2\",{children:\"#1 - Plutora Release Manager models processes across Mode 1 and Mode 2\"}),/*#__PURE__*/e(\"p\",{children:'Our teams designed Plutora to be able to adapt to your process, and Plutora can support a wide range of release and deployment processes within the same enterprise release plan.\\xa0 We understand that today\u2019s IT department spans a wide range of project management styles with agile (Mode 2) projects sitting alongside slower moving (Mode 1) projects. \\xa0Often these two projects target the same testing environments and release timelines so understanding differences in capacity requirements, governance gates, and automation approaches\\xa0is key to helping managers orchestrate across this \"Bimodal boundary.\"'}),/*#__PURE__*/e(\"p\",{children:\"When a release manager is planning a complex release process Plutora makes release dependencies easier to identify and Plutora's system impact matrix will clearly show you the systems that are impacted by a release. Using this impact matrix you can identify what systems need to be prepared for a release, and in a Bimodal environment you can take steps to deal with dependencies spanning Mode 1 and Mode 2 systems. \\xa0The key take-away is that Plutora doesn't just assume that every project is agile, we give the release manager the tools they need to model variation across projects.\"}),/*#__PURE__*/e(\"h2\",{children:\"#2 - Plutora Environment Manager can model a wide range of environments\"}),/*#__PURE__*/t(\"p\",{children:[\"Real-world, enterprise systems span a wide range of technologies, and one of the biggest challenges facing the \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" department is how to synchronize environments between slower-moving Mode 1 projects and more agile Mode 2 projects. When a Mode 1 project requires two weeks of data preparation to begin the QA process for a quarterly release how is that requirement managed alongside projects that need to release every day.\"]}),/*#__PURE__*/e(\"p\",{children:\"Mode 1 projects may have long-lived, static environments dedicated to QA and Staging while Mode 2 projects may be embracing a fast-moving approach that involves on-demand cloud infrastructure.\\xa0 For example, your Mode 1 testing and integration database may be running on a static environment in a data center that hasn\u2019t changed for years\\xa0while\\xa0your front-end teams may be making use\\xa0of public clouds to create multiple environments on-demand that only exist for the duration of a single integration test run.\"}),/*#__PURE__*/e(\"p\",{children:\"Plutora\u2019s Environment Manager doesn\u2019t ship with an assumption that all of your environments use the same, cookie-cutter approach.\\xa0 Plutora has the ability to manage both approaches within the same release timeline, and if your goal is to transition environments from Mode 1 to Mode 2 Plutora helps you identify opportunities for improvement.\"}),/*#__PURE__*/e(\"h2\",{children:\"#3 - Plutora models real capacity requirements across Mode 1 and Mode 2\"}),/*#__PURE__*/e(\"p\",{children:\"Different projects require different resources.\\xa0 A Mode 1 system that conducts infrequent, quarterly releases likely requires an \u201Call-hands-on-deck\u201D approach to regression testing that can consume an entire QA department. At the opposite end of the spectrum, a Mode 2 application deployed to production multiple times a day may require only cursory tests run by an automated system. When dealing with a release timeline spanning Mode 1 and Mode 2 you need a tool that can assess the impact on limited testing and release engineering resources.\"}),/*#__PURE__*/e(\"p\",{children:\"While system administrators and developers might think of environments and computing resources as the real capacity limits Enterprise Release Managers understand that the real capacity limits are often related to staff available to test, qualify, and execute a highly orchestrated release plan. Just as Plutora provides enterprise release managers with a way to model heterogeneous approaches to release processes Plutora also provides management with a window into real capacity. You can see how that behemoth Mode 1 project is going to take QA out of rotation for a few weeks, and you can prepare other projects to adapt to this reality.\"}),/*#__PURE__*/e(\"h2\",{children:\"Avoiding Bimodal Collisions\"}),/*#__PURE__*/t(\"p\",{children:[\"Most enterprises are running \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" departments whether they call it Bimodal or not, and resource allocation issues become apparent when a legacy system\u2019s release schedule impacts a Mode 2 release schedule. These are the events that create unrealistic release schedules that impact both system availability and department morale. You can avoid these conflicts by using a tool that can understand and predict when a Mode 1 project is about to collide with a Mode 2 project.\"]}),/*#__PURE__*/e(\"p\",{children:\"We\u2019ve talked about Plutora using Air Traffic Control analogies before and that analogy works for Bimodal. A release manager in a Bimodal environment is landing two types of projects (airplanes) on a limited number of environments (runway space.) Your challenge is to manage high-risk Mode 1 projects requiring the same resources as faster moving agile projects all impacting the same teams and systems to achieve a release that won\u2019t impact system availability.\"}),/*#__PURE__*/e(\"img\",{alt:\"Bimodal IT\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,HBi9CRHgWNlzM6ck1THaDjmWMMc.jpg?originalFilename=bimodal_it.jpg\",src:\"https://framerusercontent.com/images/HBi9CRHgWNlzM6ck1THaDjmWMMc.jpg\",srcSet:\"https://framerusercontent.com/images/HBi9CRHgWNlzM6ck1THaDjmWMMc.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/HBi9CRHgWNlzM6ck1THaDjmWMMc.jpg 1024w\"}),/*#__PURE__*/e(\"p\",{children:\"This high-wire act is analogous to dealing with several incoming Boeing 747s or Airbus 380s on the same runway space that is supporting smaller jets like a Gulfstream G650. These planes can\u2019t all land on the runway at the same time and they have different requirements for gates and support. \\xa0In a Bimodal environment, you are dealing with a similar challenge. How do you model the release pipeline and assess system impact so that you can make adjustments to Mode 1 and Mode 2 projects while they are in transit. \\xa0(Alternatively, how do you predict and prevent conflicts before that Gulfstream is only 1000 feet away from that 747?)\"})]});export const richText4=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Gartner has put a name on a common experience across all industries \u2013 IT departments often support two different approaches to IT.\\xa0 One side is focused on agility and rapid time to market while the other is focused on stability and traditional service management.\\xa0 With \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" you have one department operating in two modes: \u201CTraditional\u201D IT alongside \u201CExploratory\u201D IT.\\xa0 Gartner calls this \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\".Release managers have understood this aspect of IT for some time.\\xa0 We sit at the intersection of these two approaches when software from various projects is integrated together and transitioned from development to production.\\xa0 \\xa0Some projects require the meticulous application of the process to meet a monthly deadline while other projects are throwing code into production twice a day.\\xa0\\xa0 There\u2019s a wide spectrum of IT project types, but with \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" you put projects into two buckets: traditional and exploratory.\"]}),/*#__PURE__*/e(\"p\",{children:\"In our previous analysis, we\u2019ve talked about development have different motivations and goals as operations, but in larger organizations, it is true that there are increasingly two or more approaches to IT within one department.\\xa0 There is a different set of rules for that new website redesign vs. the installation of a new order processing database for a bank.\\xa0 Different teams working on projects require different levels of change control and a completely different approach to releases.\"}),/*#__PURE__*/e(\"img\",{alt:\"Release Managers Mind the Bimodal Gap\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,s1kzW8ZZJnJcIlsRBYhnblyN8.png?originalFilename=release-management-in-the-middle1.png\",src:\"https://framerusercontent.com/images/s1kzW8ZZJnJcIlsRBYhnblyN8.png\",srcSet:\"https://framerusercontent.com/images/s1kzW8ZZJnJcIlsRBYhnblyN8.png?scale-down-to=512 512w,https://framerusercontent.com/images/s1kzW8ZZJnJcIlsRBYhnblyN8.png 800w\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Release managers face some of their most challenging problems when these two worlds collide\"}),\" \u2013 when one of your exploratory projects needs to interact with a traditional project it is often the release manager who is responsible for translating between these two, often incompatible approaches to IT.\\xa0\\xa0 That\u2019s why we created Plutora, a tool that acknowledges the multiple realities inside most large IT departments.\\xa0 What release managers are looking for isn\u2019t a single process to manage everything. They are looking for a tool that can adapt to different styles of IT project management across projects within the same release.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Bimodal IT: Don\u2019t Cross the Streams\"}),/*#__PURE__*/e(\"p\",{children:\"If an enterprise release is properly managed then these two modes of IT will rarely interact.\\xa0 If, on the other hand, an organization isn\u2019t disciplined about the process and planning a release manager is often responsible for acting as a translator between teams focused on stability and teams focused on innovation and rapid delivery. These teams speak two entirely different languages.\"}),/*#__PURE__*/e(\"p\",{children:\"If boundaries between the Traditional and Exploratory sides of the IT department are well defined then a release manager\u2019s job is easy.\\xa0 For example, if an agile team writing a slick, well-designed web application needs to interact with a backend system they can do so through a well-defined API or a protocol.\\xa0 For example, most web applications interact with a database through a database driver and if a system is relatively mature then schema changes might be few and far between.\\xa0 In this situation, a release process can assume an almost complete disconnect between \u201CTraditional\u201D and \u201CExploratory.\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"If, on the other hand, management has added a frequent release dependency between the exploratory web-development team and the traditional database team, this is when a release process can be delayed by risks introduced by bridging this bimodal divide. Your exploratory teams will be constantly blocked by the requirements of your traditional teams.\"}),/*#__PURE__*/e(\"p\",{children:\"These problems arise because systems designed with an emphasis on stability are rarely the same systems that can support agile delivery. \\xa0\\xa0Stable, \u201CTraditional\u201D systems are subject to heavyweight process and change control for a reason \u2013 they are often fueling the core of a large business.\\xa0 Innovative, \u201CExploratory\u201D systems are often developed by small teams as a POC that isn\u2019t subject to rigorous process.\\xa0 This POC graduates to production and most organizations opt to preserve the agility demonstrated during development.\\xa0 They can release once a day, or even more frequently because they don\u2019t present the same risk profile to the organization.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"So, how do you manage both within the same IT organization? Bimodal IT.\"})}),/*#__PURE__*/e(\"h2\",{children:\"Keys to Bimodal IT Success\"}),/*#__PURE__*/e(\"p\",{children:\"Here are some tips to help manage the differences between projects in an IT department that has gone Bimodal.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Make Projects Choose a Side \u2013\"}),\" If you practice \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" you will need to create a central list of projects and initiatives and relate them to one side.\\xa0 Your web site redesign will likely be exploratory while your backend systems might be traditional.\\xa0 Don\u2019t just classify projects in IT, classify IT functions and how they are aligned to support both sides.\\xa0\\xa0 How does your change management team support traditional projects vs. exploratory projects and does one side call for changes to policy and approach?\"]}),/*#__PURE__*/e(\"p\",{children:\"If you don\u2019t classify projects and you don\u2019t adapt your systems to support both sides differently you are creating untenable conflicts for projects and throwing your application teams at a minefield of confusing and contradictory assumptions. (Does this project require change control?\\xa0 Which side is it on?)\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Take Care with Your Dependencies \u2013\"}),\" Make sure that all of your cross-project dependencies are intentional and don\u2019t just wander into a complex network diagram of cross-departmental dependencies.\\xa0 If you\u2019ve assigned projects to the Exploratory and Traditional buckets and you\u2019ve identified a project that depends on another across this boundary make sure that you understand the exact nature of the dependency.If you are not careful with this boundary then you are going to introduce obstacles into your release process.\\xa0 If your mostly exploratory projects have a single problematic dependency on a traditional project then you\u2019ll be forcing teams to wait for the very process you were trying to avoid with \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\".\",/*#__PURE__*/e(\"strong\",{children:\"Mind the Gap \u2013\"}),\" In a \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" department there are two sides.\\xa0 There are projects and functions that are designed to support a more traditional approach (rigorous change control) then there are other functions designed to support exploration (continuous delivery.)\\xa0 You\u2019ll want to make sure that projects don\u2019t get to pick and choose between these two modes depending on what is expedient at the moment.\"]}),/*#__PURE__*/e(\"p\",{children:\"If you follow an ala-carte approach to IT infrastructure it makes it more difficult to apply patterns during your release process. For example, if a project falls under a more traditional approach to management then allowing it to hook into the continuous deployment pipelines used by exploratory projects will create confusing exceptions.\\xa0\\xa0 Projects in your CDI pipeline will be designed to deploy frequently, but that one, exception needs to be run through rigorous change control before you can deploy.\"}),/*#__PURE__*/t(\"p\",{children:[\"Part of the promise of \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" is that it simplifies the challenge. Instead of dealing with a thousand shades of DevOps, you have projects that are compatible with agile approaches and projects that are not.\\xa0 If bimodal is the model you follow \u2013 mind the gap.\"]}),/*#__PURE__*/e(\"h2\",{children:\"The Future Direction of Bimodal IT? We\u2019re betting on Agile.\"}),/*#__PURE__*/t(\"p\",{children:[\"The idea of \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" is one that captures the current moment in the industry.\\xa0 Companies are moving toward a more agile, more DevOps-friendly approach to releasing software.\\xa0 At the same time, there is an undeniable reality that portions of the IT department are still supporting slow-moving, waterfall-based applications that demand strict process.\\xa0 \",/*#__PURE__*/e(\"strong\",{children:\"Bimodal is today\u2019s reality.\\xa0\"}),\"When looking at longer-term trends, it will be challenging for CIOs to embrace\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\" Bimodal IT\"})}),\" as more and more projects in IT move toward agility the \u201CTraditional\u201D half of IT will, over decades become a smaller aspect of IT.\\xa0 Agility is an infectious condition in IT, and even though it might seem impractical for legacy systems to embrace more agile approaches to manage the market will find a way to make even the most risk-averse legacy system more agile.\\xa0 \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-is-bimodal-it\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Bimodal IT\"})}),\" is a good bet for the next 10 years, but as systems continue to accelerate we predict a more agile future using systems such as Plutora to manage complexity and mitigate release risk.\"]})]});export const richText5=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Large organizations engaged in \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/what-companies-benefit-most-from-enterprise-release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"enterprise release management\"})}),\" seldom have a single \u201Centerprise release manager.\u201D\\xa0 Instead of a single, \u201Centerprise-wide\u201D responsibility, most large, decentralized organizations assign responsibility for more strategic, release management functions to several existing roles.\"]}),/*#__PURE__*/e(\"p\",{children:\"An enterprise release management practice supports and is supported by the following enterprise release management roles:\"}),/*#__PURE__*/e(\"h3\",{children:\"IT Portfolio Management\"}),/*#__PURE__*/t(\"p\",{children:[\"An \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/4-core-practices-that-define-enterprise-release-management\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"efficient ERM practice\"})}),\" provides portfolio managers greater visibility into changes affecting multiple systems to create a consolidated status for change initiatives across an entire portfolio.\"]}),/*#__PURE__*/e(\"p\",{children:\"By assembling data across multiple initiatives, ERM facilitates a process of continuous improvement at the portfolio level giving organizations a central mechanism to track common challenges and lessons learned. With ERM, IT Portfolio Managers make strategic adjustments to both staffing and spend across departments as change initiatives evolve continuously.\"}),/*#__PURE__*/e(\"h3\",{children:\"Release Management\"}),/*#__PURE__*/e(\"img\",{alt:\"Release Meeting\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,jfqtpvHx9WerPtk5aleoeBnuqk.jpg?originalFilename=office-table.jpg\",src:\"https://framerusercontent.com/images/jfqtpvHx9WerPtk5aleoeBnuqk.jpg\",srcSet:\"https://framerusercontent.com/images/jfqtpvHx9WerPtk5aleoeBnuqk.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/jfqtpvHx9WerPtk5aleoeBnuqk.jpg 848w\"}),/*#__PURE__*/t(\"p\",{children:[\"ERM creates a standard view of the end-to-end release lifecycle providing better decision support to release managers responsible for delivering software on time and under budget.\\xa0 Armed with a more detailed and accurate view of project status, \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/wp-content/uploads/2016/04/Plutora-Case-Study-Ebay.pdf\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"organizations practicing ERM are able to release more frequently\"})}),\" and with greater integrity and predictability. Dependencies between systems are tracked and release managers are able to accurately assess the impact of scheduling changes to a consolidated timeline.\"]}),/*#__PURE__*/e(\"p\",{children:\"An ERM practice maintains an up-to-date model of resources supporting a release, giving release managers the ability to gauge the capacity of an organization to support an ongoing, iterative release process by tracking organizational capacity and non-production testing environments.\"}),/*#__PURE__*/e(\"h3\",{children:\"Environment Management\"}),/*#__PURE__*/t(\"p\",{children:[\"Individuals and teams responsible for the allocation, provisioning and configuration of production and non-production environments are often at the mercy of shifting schedules and unreliable estimates of capacity requirements during the software delivery lifecycle.\\xa0 \",/*#__PURE__*/e(a,{href:\"https://books.google.co.il/books?id=E0yioD2WgLIC&pg=PA6&lpg=PA6&dq=benefits+of+enterprise+release+management&source=bl&ots=Xt15kDefud&sig=PS-eXr3G651HrCaeBSXu_KEKdEE&hl=en&sa=X&ved=0ahUKEwi00ofZ2JzMAhVeGsAKHXs8BocQ6AEIXjAK#v=onepage&q=benefits%20of%20enterprise%20release%20management&f=false\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"A comprehensive approach to Enterprise Release Management\"})}),\" incorporates production environment, non-production testing environment, and data environment effort and requirements into an overall plan to support software delivery.\\xa0 Under an ERM practice, environment management can use a continuously updated and more accurate status to make more efficient use of both physical and cloud-based infrastructure to support software delivery.\"]}),/*#__PURE__*/e(\"h3\",{children:\"Quality Management\"}),/*#__PURE__*/t(\"p\",{children:[\"With ERM, \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/wp-content/uploads/2016/04/Plutora-Case-Study-United-Energy.pdf\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"quality assurance and quality engineering managers are able to forecast\"})}),\" demand and allocate limited testing resources across multiple projects in response to shifting schedules.\\xa0 With an ERM practice, QA managers have better visibility into the release pipelines and so can better prioritize and allocate resources.\"]}),/*#__PURE__*/e(\"h3\",{children:\"IT Service Management\"}),/*#__PURE__*/t(\"p\",{children:[\"Service managers need clear visibility into the progress of the handling of their change requests and can now track them through the release process. Service managers gain confidence and are exposed to less risk as changes are deployed in a structured and repeatable way.\",/*#__PURE__*/e(\"strong\",{children:\"\\xa0\"})]}),/*#__PURE__*/e(\"h3\",{children:\"Product Management\"}),/*#__PURE__*/e(\"p\",{children:\"Under a strong ERM practice project managers are no longer spending 30-40% of their time distracting key resources with meetings to measure status or maintaining manual spreadsheets tracking progress toward a release goal.\\xa0 Project managers benefit from an always up-to-date picture of project status and are able to manage scheduling and resource conflicts across groups as they develop.\"})]});export const richText6=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Enterprise software development has undergone a dramatic transformation in the last decade as most companies have transitioned to more iterative, agile approaches to software delivery.\\xa0 This overall acceleration of the software development effort has been focused squarely on more tactical practices related to software development.\\xa0 From \",/*#__PURE__*/e(\"strong\",{children:\"source control\"}),\" to \",/*#__PURE__*/e(\"strong\",{children:\"scrums\"}),\" to \",/*#__PURE__*/e(\"strong\",{children:\"deployment automation,\"}),\" most IT departments are moving quickly and assembling a large amount of data related to software delivery.\"]}),/*#__PURE__*/e(\"p\",{children:\"Successes at the tactical level have yet to be integrated into systems to support more strategic decisions at the portfolio level.\\xa0 While single projects can move quickly using a modern toolset designed to support rapid delivery large organizations managing complex releases involving considerable risk are still forced to manually assemble information from a heterogeneous collection of disparate IT systems.\\xa0 ERM integrates information from a variety of sources to support a more continuous approach to planning and managing large-scale releases.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Systems Affected by ERMContinuous Integration SystemsDeployment Automation SystemsApplication Release AutomationChange Management SystemsProject Issue TrackersPortfolio Management ToolsMonitoring and Analytics SystemsAutomated Testing InfrastructureSource Code Management SystemsIT Portfolio Management Tools\"})}),/*#__PURE__*/t(\"p\",{children:[\"When these systems are integrated, \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" dashboards become a \",/*#__PURE__*/e(\"strong\",{children:\"single pane of information\"}),\" providing up-to-date information across the entire department giving management the ability to gauge progress immediately without introducing disruption in the form of status meetings.\\xa0 Developers working on one project can gain an immediate awareness of how the changes they are making affect the overall schedule and managers gain fine-grained insight into the progress of a project.\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" serves to connect the low-level productivity tools that have come to define agile success.\\xa0 The issue trackers, continuous integration systems, and distribution code repositories that are the signature of a new, more iterative approach to development are often in conflict with the static snapshots currently captured by today\u2019s IT management and ITSM delivery tools.\\xa0 With a modern \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" solution management tools are connected to the day to day realities of both \",/*#__PURE__*/e(\"strong\",{children:\"IT service managers and developers creating a single source of truth\"}),\" allowing management to understand status directly from the source\"]})]});export const richText7=/*#__PURE__*/e(n.Fragment,{children:/*#__PURE__*/t(\"p\",{children:[\"Across industries, \",/*#__PURE__*/e(\"strong\",{children:\" time to market\"}),\" for new software initiatives is decreasing over time and the frequency with which releases are transitioned from development to production is increasing. Put simply, every major company is turning into a software company and software is being delivered faster. This transformation is driven by the \",/*#__PURE__*/e(\"strong\",{children:\"widespread adoption of agile methodologies\"}),\" alongside the increasing prevalence of \",/*#__PURE__*/e(\"strong\",{children:\"DevOps\"}),\" as a philosophy affecting release and operational agility.Self-service deployments, release automation, and more distributed operational responsibility have created a situation where the remaining obstacles to efficient execution are self-imposed.\\xa0 While teams can move very quickly the overall enterprise and the organization is struggling to keep up. How can companies move faster while managing risks associated with large, interconnected software systems.As highly competitive markets continue to reward\",/*#__PURE__*/e(\"strong\",{children:\" organizations that can deliver quality software faster and more frequently\"}),\" it is essential that enterprises focus on identifying opportunities for greater efficiency. \\xa0It doesn\u2019t matter how quickly an individual team can deliver if that team is constantly waiting due to test environments issues or coordination problems between internal and external partners.\\xa0 Every software release should yield information leading to process improvements for the next iteration.\\xa0 \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Enterprise Release Manager\\xa0(ERM)\"})}),\" is how an enterprise accelerates.\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" supports process improvement for increasingly agile enterprises by capturing accurate status throughout all phases of the release cycle. \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" provides an institution with rich historical data that can be analyzed after every release cycle.\\xa0 Under an \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" practice-specific, release-related metrics are captured and assessed and a rigorous \",/*#__PURE__*/e(\"strong\",{children:\"post-implementation analysis\"}),\" is performed such that improvements can be identified and modifications to release strategy can be introduced into an iterative process of continuous improvement.\\xa0\\xa0\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" is an agent of change.\\xa0 Organizations can \",/*#__PURE__*/e(\"strong\",{children:\"start to track the performance of now isolated DevOps and Agile initiatives\"}),\" and establish common best practices to facilitate the transition of all projects to modern, iterative release processes.\"]})});export const richText8=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"With \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Enterprise Release Management (ERM)\"})}),\" organizations can achieve real agility above the level of individual projects.\\xa0 When management functions are informed by feeds updated continuously and when multiple departments agree upon consolidated dashboards of release progress organizations can start\",/*#__PURE__*/e(\"strong\",{children:\" focusing on efficient execution and avoid interrupting productive resources \"}),\"just to measure progress.\"]}),/*#__PURE__*/e(\"h3\",{children:\"Unlocking the Organization: Tackling Complexity\"}),/*#__PURE__*/t(\"p\",{children:[\"The more teams, departments, and projects involved in a release the more likely it is that your release processes are approaching a fundamental complexity limit. \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" is the only way to move past these organizational limits as it shifts the organizational and coordination challenges to tools that are automatically gathering data from systems that have been instrumented to provide updated snapshots of status and schedule.As teams continue to drive toward \",/*#__PURE__*/e(\"strong\",{children:\"continuous deployment \"}),\"the challenge of traditional project management approaches these limits of complexity. \\xa0While \u201Cbottom-up\u201D agility results in dramatic project or department-wide improvements this approach doesn\u2019t scale to the scope of an entire enterprise. \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" provides a model to bring low-level agility to the portfolio level.\"]}),/*#__PURE__*/e(\"h3\",{children:\"Visibility: Reality-based Management for the Enterprise\"}),/*#__PURE__*/t(\"p\",{children:[\"With \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" \",/*#__PURE__*/e(\"strong\",{children:\"IT portfolio managers and IT management have visibility\"}),\" into the progress of large-scale software projects. Without \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" the best an organization can do is guess at current status and risks.\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" is an always-on management function \u2013 it is release management integrated into the way projects and departments collaborate.\\xa0 It structures interactions and planning around a singular goal of delivering software.\"]}),/*#__PURE__*/e(\"h3\",{children:\"Greater Alignment, Greater Agility: A New Way to Deliver Software\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Enterprise Release Management \"})}),\"is the\\xa0way to coordinate and track what enterprises are already doing in a more focused manner.\\xa0\\xa0 An enterprise already has multiple release managers each focused on individual projects, but many lack an overall initiative to encourage more continuous alignment between projects.\\xa0 The enterprise already maintains calendars of release dates and plans business-functions accordingly. What most businesses lack is a consolidated view, a single \",/*#__PURE__*/e(\"strong\",{children:\"enterprise\\xa0release calendar that can be used to mitigate risk\"}),\".\"]})]});export const richText9=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"There are three characteristics that drive the need to establish a strong \",/*#__PURE__*/e(\"strong\",{children:\"Release Management\\xa0Process\"}),\"\\xa0(\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\") practice and they are all related to the complications that accompany scale:\"]}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Team Size \u2013\"}),\" The number of people involved in an enterprise release.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"System Scope \u2013\"}),\" The scope of an enterprise system and interdependencies between subsystems affected by an enterprise release.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Application Risk \u2013\"}),\" The amount of risk presented by an enterprise release.\"]})})]}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" is especially useful when an organization maintains systems so large that no one group fully understands the scope of the overall system.\\xa0 \",/*#__PURE__*/e(\"strong\",{children:\"Enterprise Release Management\"}),\" functions are designed to facilitate visibility across systems no matter the scope they cover.\\xa0 Examples include an e-commerce system implemented as a series of dedicated services including inventory, payment, and front-end web site development.\\xa0 Another example would be a large enterprise that has built a web site that interacts with a CRM system such as PeopleSoft or Siebel.\"]}),/*#__PURE__*/e(\"h3\",{children:\"Team Size\"}),/*#__PURE__*/t(\"p\",{children:[\"Companies benefiting from \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" are large enterprises consisting of multiple departments spanning one or more business units supported by one or more IT departments.\\xa0 \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" is applicable for companies with over 100 direct participants in the software delivery lifecycle.\\xa0 If a company has more than three groups coordinating to deliver software with more than 100 direct participants it is a prime candidate to benefit from \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\". \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),/*#__PURE__*/e(\"strong\",{children:\" provides a higher level of strategic release management\"}),\" to align personnel across departments and address obstacles and communication issues that may arise outside of individual groups.\"]}),/*#__PURE__*/e(\"h3\",{children:\"System Scope\"}),/*#__PURE__*/e(\"p\",{children:\"Large, composite enterprise systems are characterized by the presence of multiple interdependent subsystems including both systems developed by internal application development teams and third-party services such as content delivery networks and payment gateways.\\xa0 These composite systems involve multiple, independent development groups often spanning several organizational structures both internal and external and subsystems are linked together in a hierarchy creating an overall enterprise architecture. Changes are rarely confined to single, isolated components in a composite system and when application features or services are implemented multiple components in a composite system are impacted simultaneously.\"}),/*#__PURE__*/e(\"h3\",{children:\"Application Risk\"}),/*#__PURE__*/t(\"p\",{children:[\"High-risk industries such as e-commerce, government, and banking require a constant commitment to 24/7 availability. Uptime is the primary concern for a business designed to serve consumers and any organization of sufficient complexity is faced with the challenge of controlling the impact of software releases. \\xa0As \",/*#__PURE__*/e(\"strong\",{children:\"software releases are the primary source of downtime\"}),\" in most enterprises, there\u2019s a special sensitivity and awareness when it comes to managing release-related risk.When contingency planning isn\u2019t optional and when minutes of downtime or even transient downtime can impact the business an \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/platform/release-management\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"ERM\"})}),\" practice is required to\\xa0help\\xa0to\",/*#__PURE__*/e(\"strong\",{children:\" identify and manage risks associated with multi-project deployments\"}),\".\"]})]});export const richText10=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(a,{href:\"https://en.wikipedia.org/wiki/Enterprise_release_management\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Enterprise Release Management\"})}),\" (ERM) is an emerging set of practices designed to support enterprise change initiatives and software delivery across multiple projects within large organizations.\",/*#__PURE__*/e(\"strong\",{children:\"ERM is the management of the software delivery lifecycle across multiple projects and departments within a large organization\"}),\" \u2013 the orchestration of activities and resources across multiple, interdependent software releases and change initiatives. All in order to deliver software at scale while managing both the technical and organizational complications that accompany delivering changes to enterprise-scale, composite systems within a large organization.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Best Practices that Define Enterprise Release Management\"}),/*#__PURE__*/e(\"p\",{children:\"Enterprise release management is a practice area that covers a wide array of activities all focused on delivering software, but it is defined by a set of practices that support a multi-project, cross-functional approach to managing the end-to-end release process.\"}),/*#__PURE__*/e(\"img\",{alt:\"release management practices\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,sXG3DNTZqcYzC2edR2y4APNsvg.png?originalFilename=enterprise_release_management_practices_diagram_b.png\",src:\"https://framerusercontent.com/images/sXG3DNTZqcYzC2edR2y4APNsvg.png\",srcSet:\"https://framerusercontent.com/images/sXG3DNTZqcYzC2edR2y4APNsvg.png?scale-down-to=512 512w,https://framerusercontent.com/images/sXG3DNTZqcYzC2edR2y4APNsvg.png 640w\"}),/*#__PURE__*/t(\"p\",{children:[\"When pursuing effective enterprise release management, pay close attention to \",/*#__PURE__*/e(\"strong\",{children:\"ensure the operational health of these\"}),\" \",/*#__PURE__*/e(\"strong\",{children:\"four key best practices:\"})]}),/*#__PURE__*/e(\"h3\",{children:\"1. \\xa0Multi-project Release Coordination\"}),/*#__PURE__*/e(\"p\",{children:\"Maintaining a consolidated event calendar across all projects included in a large, composite release. This includes the orchestrated deployment of these projects to applications in the enterprise operating environment.\"}),/*#__PURE__*/e(\"h3\",{children:\"2. \\xa0Environment Management\"}),/*#__PURE__*/e(\"p\",{children:\"Tracking capacity requirements and work-effort for environments required during the software delivery process. Support decisions regarding the use of automated provisioning of environments or scheduled use of shared persistent environments.\"}),/*#__PURE__*/e(\"h3\",{children:\"3. \\xa0Automated Release Reporting\"}),/*#__PURE__*/e(\"p\",{children:\"Capturing metrics and key performance indicators for all release-related processes, gates and resources, presented in dashboards for all stakeholders to identify progress toward the enterprise release.\"}),/*#__PURE__*/e(\"h3\",{children:\"4. \\xa0Continuous Process Improvement\"}),/*#__PURE__*/e(\"p\",{children:\"Measuring release-related metrics and tracking progress across the end-to-end software delivery process to support an iterative approach to process improvement.\"}),/*#__PURE__*/t(\"p\",{children:[\"The four practices outlined above\\xa0define enterprise release management and should all be \",/*#__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:\"organized at a strategic, portfolio-wide level\"})}),\" to provide IT management with visibility into the more tactical processes that serve to support coordinated releases.\\xa0 As organizations adopt a more agile and accelerated approach to software delivery with an emphasis on best practices at a tactical level, release management provides a series of practices designed to foster and support this agility and align it with decision-makers responsible for entire portfolios.\",/*#__PURE__*/e(\"strong\",{children:\"Why does this all matter?\"})]}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"ERM is the missing link.\"}),\" Many\\xa0VPs\\xa0\",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/vps-to-release-managers-do-we-have-a-plan\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"look to project-level release managers for enterprise-wide plans\"})}),\". \\xa0This doesn't scale - enterprise releases need to be managed at a higher level.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[\"Organizations that don't take time to plan for non-production capacity requirements run the risk of \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/test-environment-management-penalty\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"making entire teams or departments wait when timelines invariably slip\"})}),\".\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[\"As \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/3-devops-considerations-for-the-enterprise\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"DevOps continues to transform the enterprise\"})}),\" it creates pressure on management to measure status without interrupting teams.\"]})})]})]});export const richText11=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Last week\\xa0wasn\u2019t a good week\\xa0for the stability of high-profile systems.\\xa0 \",/*#__PURE__*/e(\"strong\",{children:\"United airlines had a ground-stop due to an \u201Cautomation failure\u201D,\"}),\" the New York Stock Exchange suffered a problem that caused an interruption of trading, and the Wall Street Journal had issues with site availability. \\xa0United is blaming this week\u2019s outage on a bad router, the NYSE is saying this was due to a technical \u201Cglitch\u201D, and there\u2019s no word yet on what caused the Wall Street Journal to stop working.\"]}),/*#__PURE__*/e(\"p\",{children:\"My guess is that several of these sites suffered a release-related outage.\\xa0 This is the most common source of problems in high profile and high-availability systems.\\xa0 Teams coordinate to push a set of changes to a production system, and due to various factors systems in production tend to exhibit different bugs than staging and QA. The worst defects always tend to be identified in production, and in a complex system such as an airline or a stock exchange it\u2019s difficult to recreate production conditions in non-production environments.\"}),/*#__PURE__*/e(\"p\",{children:\"If you work for a large company site outages are nothing new.\\xa0 In fact there are likely several mini-outages for most websites every week that don\u2019t make it to the level of headline news. \\xa0A large e-commerce website might stop accepting orders for a few seconds during a major release, or a site like Netflix might introduce several minutes of downtime during a major release.\\xa0 These mini-outages are common and while many companies strive to bring release-related outages to zero, there are some production changes that require brief downtime.\\xa0 My own banking provider is constantly warning me that Sunday\u2019s might involve several hours of downtime.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"I\u2019m sure one of these outages was due to a code or configuration change related to a software release.\"}),\"\\xa0 A playbook was created to track a change, a team was assembled on a conference bridge to monitor the change, and a team of specialists was given the green light to flip the necessary switches to update software.\\xa0 Somewhere in the operations center of both United and the NYSE a graph started to flat-line and alarms started to go off.\\xa0 Executives and managers started to be woken up as the emergency became more urgent, and instead of completing a playbook an entire IT department was distracted by an ongoing emergency to get the trading network or the airline operational.\\xa0 This is how releases turn into emergency production support calls, and when this happens without a rollback plan that\u2019s when headlines are generated.\"]}),/*#__PURE__*/e(\"p\",{children:\"Someone on some release team had to call into a conference line and inform operations that, no, the planes cannot fly and the stock exchange can\u2019t open because someone failed to account for every possible contingency.\\xa0 Teams are under pressure, managers are under even more pressure, and every time you read one of these headlines you know there\u2019s a new group of IT managers refreshing resumes. When a business is on the line, it\u2019s the release managers that are held accountable for these failures to avert disaster.\"}),/*#__PURE__*/e(\"p\",{children:\"Software releases introduce risk and this is just a fact of the industry.\\xa0 The way to completely avoid this risk is to stop delivering software, and that\u2019s not something business can afford to do.\\xa0 Today\u2019s business face a difficult challenge we are being asked to move faster, to support DevOps and get out of the way of developers who need to move quickly.\\xa0 At the same time, our world is increasingly dependent on software, and when that software fails (even for a few minutes) it can generate headline news.\"}),/*#__PURE__*/e(\"p\",{children:\"For this reason it is important for release managers everywhere to understand that they are on the front-lines of uptime and availability.\\xa0 We aren\u2019t just simply making playbooks and deployment plans to deliver software on time and under budget, it is our job to think through contingency plans in the face of failure and to provide businesses with a fallback plan should a release cause an unintended side-effect.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"When businesses like United and NYSE suffer outages like those that happened this week\\xa0it\u2019s very likely that software delivery and/or configuration change contributed to these failures.\\xa0\"}),\" After all of the analysis is done and the root causes have been identified I have no doubt that at the center of the problem lies a series of excel spreadsheets that captured an inaccurate plan or a series of unopened emails from a release manager sitting in someone\u2019s Outlook Inbox.That both the United and NYSE failures required multiple hours (and in the case of the NYSE more than a day) to remedy suggests that these organizations may lack a unified plan for reacting to unknown failure conditions.\\xa0 At \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Plutora\"})}),\" we work with companies to facilitate release plans, but we also help companies use our tools to record playbooks that deal with disaster recovery and emergency response.\\xa0 There\u2019s very little difference between the steps required to orchestrate the delivery of software to production and the steps required to mitigate an ongoing failure.The reality of today\u2019s enterprise releases are that they are largely managed by custom spreadsheets and lengthy email chains just begging to be ignored. If we\u2019re going to evolve as an industry, and if release managers are going to be acknowledged for the value they bring it is time for all companies to adopt tools like \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Plutora\"})}),\" so they can manage complex releases that span multiple departments in a tool that provides companies with a plan for dealing with unknown failures.\"]})]});export const richText12=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Release managers understand what it means to have a triple-booked Outlook calendar. \\xa0They have calendars subject to rapid last-minute changes as project timelines slip and environments issues cause a series of fire-drill emergencies to be solved right now. Most release managers spend all day, every day in a series of meetings trying to glean the truth from project teams having little time to record information in ad-hoc Excel spreadsheets.\"}),/*#__PURE__*/e(\"p\",{children:\"This is what the pandemonium of release management without Plutora looks like. \\xa0It is an Outlook calendar full of meetings, meetings about meetings, overlapping meetings, meetings for developers to complain about BMC Remedy, and meetings to respond to downtime caused by environment contention and preparation issues. \\xa0In summary, the calendar shown below is the disaster that most release managers are familiar with. There's not even time to eat lunch this schedule is so busy.\"}),/*#__PURE__*/e(\"img\",{alt:\"This is your Outlook calendar without Plutora\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,s3qhbOilmK1knXbyqDbrwYWoQk.png?originalFilename=Screenshot-2015-06-06-07.02.24.png\",src:\"https://framerusercontent.com/images/s3qhbOilmK1knXbyqDbrwYWoQk.png\",srcSet:\"https://framerusercontent.com/images/s3qhbOilmK1knXbyqDbrwYWoQk.png?scale-down-to=512 512w,https://framerusercontent.com/images/s3qhbOilmK1knXbyqDbrwYWoQk.png?scale-down-to=1024 1024w,https://framerusercontent.com/images/s3qhbOilmK1knXbyqDbrwYWoQk.png 2008w\"}),/*#__PURE__*/t(\"p\",{children:[\"With Plutora your schedule has fewer meetings because Plutora is connected to the systems that are\",/*#__PURE__*/e(\"strong\",{children:\" capturing project status continuously\"}),\". Instead of having to sit in on project meetings just to understand what is happening, your master release schedule in Plutora is going to be updated as issue status is updated. Your environment managers are going to address environment contention and conflicts before they become a problem, and your teams will spend less time dealing with outages and more time on proactive planning informed by accurate reports. Developers won't need to be trained on how to file BMC Remedy change requests because Plutora can automate these connections.\"]}),/*#__PURE__*/e(\"img\",{alt:\"This is your Outlook Calendar on Plutora\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,LAz5dP9lRlxTICWNTsRr187klc.png?originalFilename=Screenshot-2015-06-06-07.14.57.png\",src:\"https://framerusercontent.com/images/LAz5dP9lRlxTICWNTsRr187klc.png\",srcSet:\"https://framerusercontent.com/images/LAz5dP9lRlxTICWNTsRr187klc.png?scale-down-to=512 512w,https://framerusercontent.com/images/LAz5dP9lRlxTICWNTsRr187klc.png?scale-down-to=1024 1024w,https://framerusercontent.com/images/LAz5dP9lRlxTICWNTsRr187klc.png 2006w\"}),/*#__PURE__*/e(\"p\",{children:\"More important than all of that, with Plutora you can have lunch without feeling guilty for missing more meetings.\"})]});export const richText13=/*#__PURE__*/e(n.Fragment,{children:/*#__PURE__*/e(\"div\",{children:'\u201CHey, can we get another QA environment?\u201D That question can ruin an environment manager\u2019s day. A large organization plans for capacity, purchases enough infrastructure to support as many environments as the organization needs at once, and even \"on the cloud\" resources have a price. Several teams asking for new environments \u201Cout-of-band\u201D force environment managers to scramble for resources at the last minute.Environment Management: It\u2019s ComplicatedIt\u2019s also just a symptom of the fact that most organizations don\u2019t account for the work involved in procuring new environments, configuring them, and figuring out who is using which environment when.\\xa0\\xa0 The problem for environment managers isn\u2019t technical, it\u2019s organizational, and we created Plutora\u2019s Environment Manager because we couldn\u2019t find a tool that understood the fundamental problem - communication and coordination.The challenge for today\u2019s environment managers is managing and predicting budget and making sure that there are enough resources available to support however many environments will be required.\\xa0\\xa0 It\u2019s more than just provisioning enough VMs for an environment and making sure that application software is deployed via an automated CI system like Jenkins or Bamboo, it\u2019s about service-level dependencies for environments, tracking which groups are responsible for environments, making sure that support staff are available to support an environment.Environment management is about making sure that 1000 VMs are not just sitting there unused at any given time for lack of planning while also making sure that development groups have some room for expansion if they need it. It\u2019s about orchestrating the complex workflows necessary to motivate a whole range of departments to coordinate and communicate with one another to make sure the appropriate data is loaded into the appropriate environments.\\xa0 \\xa0Envirnonment management is also about making sure the right people have the right level of access to newly provisioned infrastructure.Most critically, Environment Management is about being able to give finance some advance warning about the budget required for QA, Staging, and Testing environments.I might have an environment. Give me a day to figure it out.That\u2019s why getting a random, out-of-band request for a new environment tomorrow can be so frustrating.\\xa0 It illustrates how reactive release managers have to be in today\u2019s enterprise.\\xa0 We\u2019re constantly waiting for that surprise request for a few hundred VMs to support a last-minute performance test or unplanned release process.Even though we\u2019re always over provisioning, we still run out of infrastructure and have to call up finance to approve another budget revision to account to unexpected hardware needs.\\xa0 We\u2019re always getting capacity estimates from development groups and multiplying them by a correction factor of 4x because we know that developers seldom understand how to model infrastructure needs as applications evolve.You end up overestimating to compensate for unpredictability and you lose cores due to inefficiency and lack of communication. When we help environment managers setup Plutora for the first time the most frequent piece of feedback we get is that Plutora helped organizations reduce overall demand for environments by an average of 25% just by shining a light on unused environments. It\u2019s amazing how much money a RACI matrix per environment and a little transparency can save a large enterprise.'})});export const richText14=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"We\u2019ve compared release managers to air traffic controllers in previous blog posts. For test environment managers we use a different analogy, instead of air traffic controllers a test environment manager job\u2019s is more akin to assigning and preparing gates for flights arriving to and taking off from a busy airport. An environment manager\u2019s job is fast paced assignment and reassignment of resources in reaction to constantly changing conditions.\"}),/*#__PURE__*/e(\"p\",{children:\"When projects fall behind schedule or, more rarely, when projects arrive at testing and verification well ahead of schedule, there can be delays because the necessary infrastructure and personnel are not yet available.\\xa0 When an organization is getting ready for a holiday season or a major project launch there are often \u201Cno gates available\u201D for projects to use.\\xa0 And, if your projects are vying for limited resources you find ways to ensure that projects are ready to \u201Cboard\u201D a test environment quickly to avoid further delays.\"}),/*#__PURE__*/e(\"p\",{children:\"As a test environment manager at a large organization you might not be handing out upgrades to first class, but the experience of fielding calls from a large organization of impatient users and developers can often leave you with the feeling that you are running O\u2019Hare during the Thanksgiving travel season.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Welcome to the Test Environment Management \u201CPenalty Box\u201D\"})}),/*#__PURE__*/e(\"p\",{children:\"While the default answer to \u201Ccan I have a new test environment tomorrow?\u201D is often \u201CNo, please file a support ticket.\u201D More often than not a test environment manager is going to do what they can to see if they can fit your project in to an existing environment.\\xa0\\xa0 A project asks for a new test environment, and you look at a manual spreadsheet to figure out what\u2019s available and what\u2019s not available.\\xa0 Sometimes you can shuffle resources around to make it work, but often you can\u2019t.\\xa0 While you can spin up a new instance of an application in the cloud, your organization is still likely bound by a real budget and test environments require a real investment of time.\"}),/*#__PURE__*/e(\"p\",{children:\"The truth of the matter is that, yes, the group asking for a new QA environment could probably get a new QA system if other groups did a better job of keeping track of how they use test environments.\\xa0 You hand out test environments to groups every day that are in different stages of readiness.\\xa0 You might have a group that has a test environment reserved for two weeks that only really needs it for two days but they asked for two weeks of time to make sure they had ample time for testing.\"}),/*#__PURE__*/e(\"p\",{children:\"Without Plutora you don\u2019t have insight into what\u2019s happening with your environments across the organization.\\xa0 Instead of being able to identify opportunities for test environment reclaim you just end up provisioning more hardware or telling projects they have to wait.\\xa0 This waiting drives up the cost of developing software as entire teams are often blocked due to test environment outages or contention.\\xa0\\xa0 And this is pure time lost, think of a plane full of passengers on a 777 that arrives at an airport two hours early \u2013 everyone is stuck on that plane waiting for a gate assignment in a section of the taxiway known as the \u201Cpenalty\u201D box.\"}),/*#__PURE__*/e(\"p\",{children:\"You can tell I spend a lot of time in airports, and this \u201Cpenalty box\u201D experience always reminds me of IT environment management.\\xa0 You have teams rushing to get the project complete under budget and on time only to be met with \u201Cwe don\u2019t have QA environments ready for testing.\u201D\\xa0\\xa0 Teams can\u2019t move on to the next requirement or the next release because software releases usually require the full attention of entire projects. You can have teams of 30-50 being asked to just take extra long lunch breaks for a week until the environment \u201Cissue\u201D is resolved.\\xa0 This is real waste and real time lost.\"}),/*#__PURE__*/e(\"h2\",{children:\"Test Environment Anti-pattern: Permanent Allocation\"}),/*#__PURE__*/e(\"p\",{children:\"Project\u2019s that have been frequently affected by test environment outages usually learn to ask for perpetual test environments.\\xa0 A high-profile website or a project for a high risk business unit will just ask for a permanent QA environment or a permanent Staging environment, and this works.\\xa0 It solves the problem of environment contention, but it also creates massive inefficiencies and lost opportunities for environment reclaim and reuse.\"}),/*#__PURE__*/e(\"p\",{children:\"It also runs contrary to the benefits of using cloud-based infrastructure.\\xa0 If your non-production test environments are permanent it doesn\u2019t encourage the dynamic approach to test environment configuration and scaling that modern DevOps should be practicing. If a group needs three QA environments and three staging test environments during a particularly busy development season then they will likely amass this many test environments until either someone self-reports that they no longer need these test environments (this never happens) or there is a critical shortage of infrastructure that prompts a test environment audit.\"}),/*#__PURE__*/e(\"p\",{children:\"Development teams have been trained to \u201Chold on\u201D to test environments even when they don\u2019t need them especially if the organization has a track record of being resource constrained.\\xa0 The ironic side-effect of this tendency to hold on to test environments even when they are not in use is that it makes the organization increasingly resource constrained while creating a situation where most test environment are underutilized.\"}),/*#__PURE__*/e(\"h2\",{children:\"Managing Test Environment Reservations with Plutora\"}),/*#__PURE__*/e(\"p\",{children:\"It is this test test environment creep, this under-utilization of non-production test environments that drove the design of Plutora\\xa0Test Environment Manager.\\xa0 This product was created to help companies avoid absurd situations where huge teams were being asked to wait for test environments because test environment managers lacked true insight into what current test environments were being used for. When we\u2019ve configured test Environment Manager for companies they\u2019ve reported immediate cost savings \u2013 projects are waiting far less than they used to without Plutora and departments have been able to quickly uncovered cases when these permanent or perpetual test environments were unnecessary.\"}),/*#__PURE__*/e(\"p\",{children:\"If you suffer from \u201Ctest environment creep\u201D and if you feel like your teams are constantly in the test environment \u201Cpenalty box\u201D use Plutora to manage reservations for test environments.\\xa0 In Plutora when a group requests a test environment they reserve it. They make a request for a test environment with a set start and end date and they provide a business justification for an environment.\"}),/*#__PURE__*/e(\"p\",{children:\"While most groups are going to end up with one or two dedicated test environments, this \u201Creservation\u201D approach to test environment management gives you and the teams you support greater visibility into how teams are planning to move systems through development, testing, and delivery and how this will affect your test environment needs going forward.\\xa0 Reservations also allow you to plan for contengiencies. What would need to be done to the reservation schedule if a project slips or is a project shows up at the gate a few hours early.\"}),/*#__PURE__*/e(\"p\",{children:\"One thing is clear, no one likes being stuck on a 777 for two hours because they can\u2019t find someone to operate jetway.\"})]});export const richText15=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"When Forrester analysts Amy DeMartine and Kurt Bittner wrote \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/wp-content/uploads/2015/05/Forrester_The_Seven_Habits_Of_Highly_Successful_DevOps_10-2014.pdf\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"\u201CThe Seven Habits of Highly Effective DevOps\u201D\"})}),\"\\xa0the habit I focused on was habit number one: \",/*#__PURE__*/e(\"em\",{children:\"\u201CEstablish trust and transparency between Dev and Ops.\u201D\"}),\" This is at the core of release management: DevOps Trust and Transparency - ensuring that both sides of this equation agree when it comes time to ship software.\"]}),/*#__PURE__*/e(\"p\",{children:\"In that report they compare DevOps to therapy for a broken relationship between Dev and Ops listing the stereotypes that either group has about the other. Bridging the divide between these two departments can, at times, feel like counseling an organization to communicate better. I\u2019ve had many meetings with both Ops and Dev teams simply to find a way to make one side understand the other\u2019s motivations when it comes to production control and release management.\"}),/*#__PURE__*/e(\"p\",{children:\"Dev wants to move quickly, and they often make oversimplifying assumptions about what is required to support software in production. Ops would love nothing more than stability even if it means that critical software updates are blocked to preserve uptime. Bridging the gap means having lots of meetings, translating different vocabularies, and becoming an expert at understanding what motivates each team.\"}),/*#__PURE__*/e(\"h2\",{children:\"Release Management is Shuttle Diplomacy\"}),/*#__PURE__*/e(\"p\",{children:\"\u201CShuttle diplomacy\u201D is a term used in international relations. Think of two sides of a contentious conflict - so contentious that they refuse to meet with each. It\u2019s often up to a small group of diplomats and negotiators to literally \u201Cshuttle\u201D between two hotels in a neutral city to bridge this disconnect. Once an agreement is in sight, only then will the two parties agree to a meeting. For a complex, risky software release the process of negotiating timelines and developing plans to mitigate risks often feels like the asking operations to surrender to the possibility that site availability may be affect by a software release.\"}),/*#__PURE__*/e(\"p\",{children:\"Whether you feel like a therapist or the Secretary of State, the process of building a dialog between Development and Operations suffers from a disconnect made more difficult by the incompatibility of the tools either side uses to communicate. Effective DevOps is about relationships between people within the IT department, but it is also about adopting tools such as Plutora that can translate between two groups.\"}),/*#__PURE__*/e(\"h2\",{children:\"Establishing a Common Language for DevOps\"}),/*#__PURE__*/e(\"p\",{children:\"Plutora saves you from having to be the middle-man to a complex negotiation between Development and Operations because it establishes a common language for releases. Let\u2019s examine three common disconnects between Development and Operations:\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Issue Numbers versus Change Request IDs\"}),\" \u2013 Developers understand code and the issues filed in systems like JIRA to track feature requests and bug fixes. When a developer needs to understand the root cause of a bug they will think in terms of SCM commits and issue numbers. \u201CIs this change related to ITP-324?\u201D When an operations professional calls them up and talks about a request number in BMC Remedy the game is already lost. \u201CIs this change covered by CR3000923?\u201D Plutora gives everyone insight into the issues that comprise a change request ticket because it is responsible for automating the flow of information between these two systems.\",/*#__PURE__*/e(\"strong\",{children:\"Project Codenames versus System Names\"}),\" \u2013 Developers get creative with project names. The next version of the homepage isn\u2019t \u201CHomepage version 2.0\u201D; it is some arbitrary codename like \u201CPhoenix\u201D or \u201CWasabi.\u201D Teams of developers will rush to deliver \u201CWasabi\u201D without even thinking that operations views this as aversion 2.0.4 running on the production network. While this might seem like a small disconnect solved by an email mapping project codenames to version numbers, think about an organization with more than two development teams and hundreds of systems in production. Plutora provides both sides with a single source of truth for what\u2019s going into production and what people should call it.\",/*#__PURE__*/e(\"strong\",{children:\"Release Versions versus Release Dates\"}),\" \u2013 Once a developer pushes code to production they might get a call from a system administrator, \u201CWhat code did you push last Thursday?\u201D In most organizations without Plutora, the release process is a mystery owned by a small core of developers \u2013 the ones that have the patience to focus on this \u201Clast mile\u201D of development. Unless the organization has built-in instrumentation to quickly identify what code version is in production most developers won\u2019t know the answer right away. They will have to step back through source code and figure out when a binary was shipped to production. With Plutora both operations and development can look at a history of changes \u2013 an end-to-end history that doesn\u2019t have gaps due to miscommunication.\"]}),/*#__PURE__*/e(\"h2\",{children:\"What Trust and Transparency Looks Like\"}),/*#__PURE__*/e(\"p\",{children:\"Plutora brings transparency to a department by filling in the information gap that exists between Dev and Ops. Developers and project managers create a rich trail of information about changes in a release and the process used to qualify a software release. It is this essential data that is often \u201Cwalled off\u201D from operations. Operations personnel use tools like BMC Remedy and Service Now to track production changes, but these two systems never meet.\"}),/*#__PURE__*/e(\"p\",{children:\"With Plutora they do meet, and over time you\u2019ll find that operations departments and application development teams start to appreciate one another\u2019s roles. Developers understand the process and procedure necessary to promote code from \u201Ccode complete\u201D to \u201Clive in production,\u201D and operations professionals appreciate having a window into the development process.\"}),/*#__PURE__*/e(\"p\",{children:\"As this trust and transparency becomes more established it encourages a new way of thinking about software releases. With Plutora, developers become more aware that \u201Coperations\u201D isn\u2019t a separate process to be separated from development. Instead, they understand that it is an essential part of the software development lifecycle to understand how code is qualified and delivered to production. Developers start taking a more proactive role to ensure that production changes can be tracked and that teams are made available to communicate about upcoming releases before they surprise a production support team.\"}),/*#__PURE__*/e(\"p\",{children:\"On the other side of the wall, operations professionals focused on infrastructure and uptime gain the ability to predict releases in a way that increases trust. Without Plutora, there\u2019s a Wall of Confusion between the two departments and operations has very little ability to predict what\u2019s going to be thrown over that wall. Without Plutora operations feels like they are under constant surprise attack by development teams that advertise false or constantly slipping schedules.\"}),/*#__PURE__*/e(\"p\",{children:\"With Plutora you\u2019ve invited both parties to the table to start the continuous process of learning how to communicate.\"})]});export const richText16=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:'This post could have also been titled \"Questions Release Managers should be Prepared to Answer.\" \\xa0Imagine you report to a VP who is asking you questions about how prepared you are for releases and how you are addressing a set of emerging issues. Everyone who has participated in release management understands that software change is risk and you\\'ll never be working under ideal conditions, but the difference between a good release manager and a great release manager is how that manager mitigates risk and manages unpredictability.'}),/*#__PURE__*/e(\"p\",{children:\"If you are a release manager, the key to success is knowing how to respond to emails like these from your manager. Release management has grown more challenging: the average size of IT portfolios increases every year and the frequency of releases mean that release managers find themselves the center of attention. Executives are starting to notice that release management can make the difference between success and failure and they are starting to ask difficult questions like these:\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Do we have a plan for a rollback? and, have you rehearsed this plan on a staging environment?\"}),\"\\xa0Before we\\xa0suffer through another debacle like the last release I want to know if you've anticipated failure scenarios. \\xa0The fact that it took us so long to recover during last week's outage was a \\\"black eye\\\" for the whole department, and the executives I answer to were surprised that we didn't have a rollback plan. Can you show me what our plans are for rollback?\",/*#__PURE__*/e(\"strong\",{children:\"Can you show me a report of success rates for releases broken down by application team?\"}),\"\\xa0 I know that application teams bear some responsibility for failed\\xa0releases. I want to know which teams have the most problematic history with releases and I want to follow up with each Director on the root cause for these problems. If there's a team causing problems because they are using production as a testing environment then I expect you to keep track of that for me. \\xa0It's no longer acceptable for the site to just \\\"stop working\\\" every time we run a release.\",/*#__PURE__*/e(\"strong\",{children:\"How much downtime can be attributed to the release process?\"}),\"\\xa0Management understands that upgrades and maintenance can cause some downtime, but we're seeing consistent problems every time even a minor fix is deployed to production. \\xa0Again, I understand that you are responsible for the release process and not the quality of the software (that's QA's job and I have another email to the QA Director similar to this), but if it's release-related than I want a plan from you detailing what is being done to ensure that we're not introducing avoidable downtime.\",/*#__PURE__*/e(\"strong\",{children:\"How much time is our department\\xa0spending on the change control process?\"}),\"\\xa0I'm not going to be able to do away with the change control process and the CAB meetings, but if you can give me a detailed report of how much time we're dedicating to it then I will have an argument to stand on the next time I'm asked to defend you for taking the necessary shortcuts. CAB meetings are a real hassle, especially as we move to daily minor releases. I'm talking to the CEO next week about simplifying this process, and it would help to have these numbers assembled.\",/*#__PURE__*/e(\"strong\",{children:\"How much of our release is automated? and how much requires manual effort?\"}),\"\\xa0Our QA director is complaining about how late the QA team has to stay up to support post-release verification, and the engineers we've recently hired have all identified our release process as being surprisingly manual when compared to our competition. If we're going to be performing more frequent releases you need to provide me with a plan that targets 90-100% automation. \\xa0I understand that there are parts of the process that might not lend themselves to automation, but I need your team to focus on more critical items not this robotic, release work that keeps our people up until 4 AM. \\xa0What I want to see is a system that is fully automated across the board.\",/*#__PURE__*/e(\"strong\",{children:\"Is your team looking into how we handle configuration management?\"}),\" \\xa0From my perspective our process focuses on copying the right software to the right systems at the right time, but our configuration story still feels very manual. \\xa0Individual teams are making configuration changes in production without oversight. I'd like our release management effort to have end-to-end control over production state because I'm not comfortable with the current set of unknowns. \\xa0Research the latest best-practices for configuration management and write a report about the current best practices and how we align with emerging standards.\"]}),/*#__PURE__*/e(\"p\",{children:\"Common themes in these emails are transparency, tracking, and automation. VPs and senior IT managers are looking to release management to address waste and inefficiency and to solve some of the most difficult problems they face. If you find yourself facing similar questions Plutora's Release Manager is a perfect tool to help answer them. With Plutora you can send your management a clear message that you are working toward a solution and measuring the appropriate metrics. \\xa0If management is going to be paying closer attention to release management plan to provide them with solid answers backed by Plutora Release Manager.\"})]});export const richText17=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"img\",{alt:\"Production Deployments are a High-wire Act without Plutora\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,PAjZQ1wZotwFArzjxiqfRiW08Q.jpg?originalFilename=high-wire-youngerdude.jpg\",src:\"https://framerusercontent.com/images/PAjZQ1wZotwFArzjxiqfRiW08Q.jpg\",srcSet:\"https://framerusercontent.com/images/PAjZQ1wZotwFArzjxiqfRiW08Q.jpg 566w\"}),/*#__PURE__*/e(\"p\",{children:\"It\u2019s 3 AM in California, and you are still awake trying to sort through a release process that has been delayed by several hours. The deployment to the main application cluster took several extra hours due to an unanticipated problem with the servers, and now everyone is waiting on the lead database administrator to call into a conference bridge so you can all move on to Step 53.5b of the deployment. Your production deployments always seem to be problematic and this one might be the worst you've experienced yet.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Everyone\u2019s Tired: Bad Decisions Abound\"}),\"By \u201Ceveryone,\u201D I mean the 30 QA testers and 3 project managers in California, several developers in Sydney and India, and an operations team spread throughout the EU and the US. You can tell by some of the ambient noise on this conference call that people are starting to falter.\"]}),/*#__PURE__*/e(\"p\",{children:\"Your California team is up at 3AM and exhausted to the point that they are making irrational decisions about risk and pushing changes without adequate testing. Some people on the bridge are yawning while others are just waking up. You work for an impressively global organization, but it\u2019s times like these that make you realize your release process needs to be refactored to allow for more sleep.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"What Time Zone is this Spreadsheet Using?\"}),\"Your developers are attentive and well rested, but the deployment playbook Excel spreadsheet lists a sequence of events to be completed with times like 11 PM and 10 PM. \u201C10 AM shift all traffic to backup database. 10:30 AM upgrade database. 11:00 AM deploy new code to application servers.\u201D\"]}),/*#__PURE__*/e(\"p\",{children:\"There\u2019s no mention of time zone in this spreadsheet which means that the Sydney team is constantly asking, \u201CThis release plan is in PST, right?\u201D You run a global company, but no one bothered to add time zone to the release plan; unfortunately, this caused problems when the team in India decided that \u201C10 AM\u201D meant \u201C10 AM Bangalore time.\u201D Twelve and a half hours before the release was even scheduled to start, your production database was taken offline and upgraded. You make a mental note to yourself \u2013 \u201Cspecify time zones on all release spreadsheets.\u201D\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"\u201CNo one else can run Step 53.5b, really? Can someone call Jack?\u201D\"}),\"Six months ago you scheduled an emergency meeting to convey with a sense of urgency that every project must have a repeatable, automated release process. Most of the teams responded quickly: the application team perfected a series of scripts to automate deploys, but the DBAs are another story. Six months later you have a DBA on the phone informing you that no one other than the lead DBA \u2013 Jack \u2013 can run the necessary scripts to modify replication settings in production.\"]}),/*#__PURE__*/e(\"p\",{children:\"You make another note \u2013 \u201CTell DBA team manager to ensure that all production deployments have coverage.\u201D Tired and annoyed you tell the team, \u201COk, can someone get Jack on the phone so we can move forward?\u201D Minutes turn into hours. At 4AM your team reports that Jack isn\u2019t picking up his phone and someone remembers that he might just be camping in the middle of the Australian outback. There\u2019s no wireless signal within miles of Jack so your entire release now depends on seeing if the intern can figure out what steps Jack would have performed on your production database. Everyone is blocked.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Time to Rollback?\"}),\"You are beginning to have that sinking feeling that you might have to tell everyone to execute the rollback plan. That\u2019s not something you want to have to start unless you have to, but it\u2019s 4 AM and your deployment window is going to end. There\u2019s one problem: no one bothered to update the rollback plan so you are not even sure it\u2019s possible.\\xa0\"]}),/*#__PURE__*/e(\"p\",{children:\"\\xa0A rollback also requires the input of management\u2026\"}),/*#__PURE__*/t(\"p\",{children:[\"\\xa0\",/*#__PURE__*/e(\"strong\",{children:\"Another Broken Production Deployment? How Surprising.\"}),\"The VP called into the bridge to check on status and made a sarcastic comment about how surprised he was that we were having problems. He wasn\u2019t really. He's used to production deployments reflecting poorly on his\\xa0leadership skills. In that sarcastic remark is a hidden message to you: fix this or I will find someone who can and I'm not waiting much longer.\"]}),/*#__PURE__*/e(\"p\",{children:\"This happens every time your team does a release, and you keep on having to explain it away to management as something that comes with the territory of running a \u201Ccomplex system.\u201D The only reliable constant in your organization is that your release process causes serious downtime, and after months of effort it still isn\u2019t getting better.\"}),/*#__PURE__*/e(\"p\",{children:\"\\xa0Your valid excuse consists of pointing to the tools used to manage the release process \u2013 a combination Excel Spreadsheets, wiki pages, and Remedy tickets. You tell your management that teams can\u2019t communicate with each other because there\u2019s no coordination between systems. One team might be focused on JIRA and Rally while the other might be focused on BMC Remedy.\\xa0\\xa0 Instead of having one tool to hold teams accountable your team ends up starting 120 person email threads and you are sure several teams don\u2019t read your release announcements.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"A Hundred Wikis with an Excel Spreadsheet Playing Catch-up\"}),\"The problem isn\u2019t entirely tool-focused, but there\u2019s no reliable way for your teams to surface management issues and other problems in a transparent way. Your broken deployment process is a symptom of a larger issue with. You lack a consistent approach to deployments because your deployment process is spread across a hundred Wiki pages, fifty development teams, and a high-level Excel spreadsheet that is always playing catch-up. \\xa0\"]}),/*#__PURE__*/e(\"p\",{children:\"It doesn\u2019t have to be like this. Your deployments don\u2019t have to be a high-wire act that always seems to end in one of your systems failing in production.\"}),/*#__PURE__*/e(\"p\",{children:\"With Plutora\u2019s Deployment Manager you can keep track of your deployments alongside the releases and environments they are designed to orchestrate.\\xa0\\xa0 You can identify the people responsible for each step and ensure that everyone understands exactly what schedule is happening when.\\xa0\\xa0 You\u2019ll have a single source of truth for release status so that you don\u2019t have to spend 40 hours on the phone asking, \u201CWhat step are we on now?\u201D\"}),/*#__PURE__*/e(\"p\",{children:\"If you are looking for release play books that can be measured and evolved over time it\u2019s time to start using Plutora.\"})]});export const richText18=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"img\",{alt:\"jenga\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,PZgogERUbSlv8DAilzSCt1qAFxY.jpeg?originalFilename=jenga.jpeg\",src:\"https://framerusercontent.com/images/PZgogERUbSlv8DAilzSCt1qAFxY.jpeg\",srcSet:\"https://framerusercontent.com/images/PZgogERUbSlv8DAilzSCt1qAFxY.jpeg?scale-down-to=512 512w,https://framerusercontent.com/images/PZgogERUbSlv8DAilzSCt1qAFxY.jpeg 631w\"}),/*#__PURE__*/e(\"p\",{children:\"How many issue trackers does your organization run? \\xa0How about change management systems? \\xa0If you are a large organization, the answer's probably more than a handful due to the way business grows through mergers and acquisitions. When managing a release driven by projects using separate issue trackers most retreat to spreadsheets to create a common picture of release status.\"}),/*#__PURE__*/e(\"p\",{children:\"With Plutora you don't have to do that. \\xa0Just use our software to integrate with the source systems and bring information together to create a single, unified view of your releases and your environments.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Many Teams, Many Systems\"})}),/*#__PURE__*/e(\"p\",{children:\"You take an organization used to practicing waterfall and transform it over the course of a decade to an organization that has fully embraced Agile, and it\u2019s likely that you are running every issue tracker known to mankind.\\xa0 As Agile has grown up over the last few years so have the tools.\\xa0 As tools like JIRA and Rally continue to evolve and mature a large corporation with several business units often runs multiple copies of each system.\"}),/*#__PURE__*/e(\"p\",{children:\"Maybe you\u2019ve standardized on JIRA to track issues or support request?\\xa0 Maybe you\u2019ve adopted Rally to manage all an agile software development practice? Or, maybe you have a mixture of newer tools such as Trac, Pivotal Tracker, or something like Trello to track individual team status.\\xa0\\xa0 But, if you are a large company acquiring other companies you understand what it means to run several of these systems at once.\\xa0\"}),/*#__PURE__*/e(\"p\",{children:\"You also understand the futility and risk associated with asking teams to switch tools \u201Cmid-stream.\u201D Maybe your front-end groups prefer to use a tool like Rally and that highly effective services group responsible for accounting uses Trello even though your corporate standard is JIRA. \\xa0\\xa0Release managers are pragmatic and most understand that teams often require different tools for different projects.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"At Plutora Integration is Our Focus\"})}),/*#__PURE__*/e(\"p\",{children:\"At Plutora we understand this.\\xa0 We understand that the modern enterprise might been running several independent issues tracks or change management systems at once, and we also understand that in this situations bringing information together \u2013 assembling release status across disparate systems is the kind of challenge that can add millions of dollars of wasted time and effort to your department.\"}),/*#__PURE__*/e(\"p\",{children:\"We\u2019ve designed our software to work with anything.\\xa0 Integration at the enterprise level is always a challenge, and it is our first priority to make sure that our customers are surprised by how easy it is to get data to Plutora and to get data from Plutora. Plutora wasn\u2019t designed to replace a JIRA or a ServiceNow or a Rally.\\xa0 It was designed to integrate and amplify the existing you use to produce quality software.\"}),/*#__PURE__*/e(\"p\",{children:\"When it comes to portfolio management, change control, source control, or issue track - if your company uses it there\u2019s a good chance that we support it, and if we don\u2019t have integration out of the box Plutora offers an API to encourage this integration, and our teams are ready to assist.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"We integrate, we don\u2019t dictate.\\xa0\\xa0You're in control of your release process.\"})}),/*#__PURE__*/e(\"p\",{children:\"Plutora doesn\u2019t show up one day and tell you how your release process should work.\\xa0 With our software you take the time to understand how your release processes works knowing that our software is there to integrate no matter how complex or challenging the integration problem is. We work with the software and systems you depend on and we take valuable information from disparate systems and bring it together to give executives and management the information they need to assess release management and environment management efforts.\"})]});export const richText19=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Do you think development teams really update those BMC Remedy tickets with all the changes contained in a release?\\xa0 They don\u2019t.\\xa0 Most of them just \u201Ccheck the box\u201D and move on.\"}),/*#__PURE__*/t(\"p\",{children:[\"They choose a risk level that won\u2019t raise questions from the change management managers and they work around the checks and balances.\\xa0 The alternative is to stop and wait for a department that still thinks releases are rare events. When a release happens every day there\u2019s just not enough time for people to attend \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/cab-and-release-management-whats-the-connection\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"CAB meetings\"})}),\" and file never-ending streams of CR tickets. Agile change management can\u2019t keep up with development.\"]}),/*#__PURE__*/e(\"p\",{children:\"To be an effective Agile Release Manager at many organizations is to master the skill of knowing how to work around change management processes. When someone asks how risky a release is the answer often depends on who is asking.\"}),/*#__PURE__*/e(\"p\",{children:\"You\u2019ll hear release managers say things like, \u201Cmark every release as a Risk Level 2 so we don\u2019t have to document potential business impact\u201D or \u201Cjust go ahead and clone the last CR ticket, no one ever checks the CR.\u201D\"}),/*#__PURE__*/e(\"h2\",{children:\"Agile Change Management: The illusion of governance and have the risk under control\"}),/*#__PURE__*/e(\"p\",{children:\"Departments in charge of tools like BMC Remedy understand this and some accept that the change requests entered rarely contain accurate or complete information. For many, the process and ceremony of ITIL is more important accuracy.\\xa0 It\u2019s governance for the sake of governance, and without accurate CR tickets, it creates the illusion of risk management. \\xa0And, from a management perspective, it is a massive waste of resources and a drag on productivity.\"}),/*#__PURE__*/t(\"p\",{children:[\"When a development team is ready to deploy features once a day, and when a development team has transitioned away from big, monthly releases the distinction between an \u201Cemergency\u201D fix, a \u201Cminor\u201D release, and a \u201Cmajor\u201D release no longer makes any sense. When developers are singularly responsible for implementing a change and triggering a \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/continuous-integration-continuous-delivery-continuous-deployment\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"continuous deployment\"})}),\" to production that complex flowchart involving a change advisory board and change coordinator has become irrelevant to the reality of your releases.\"]}),/*#__PURE__*/e(\"p\",{children:\"On one side of the fence is a development team that is ready to deploy to production multiple times a day.\\xa0 On the other side is an ITIL-based production control team that looks less relevant every single day because they haven\u2019t adapted to the increasing pace of change. An enterprise experiencing this disconnect has lost track of why changes to production are tracked in the first place.\"}),/*#__PURE__*/e(\"h2\",{children:\"Bridging the gap to reduce risk\"}),/*#__PURE__*/e(\"p\",{children:\"Something needs to be one to bridge this gap. This disconnect between ITIL-based process mandated by large enterprises and the way that development teams operate is getting worse. While many organizations have started to err on the side of enabling development teams they\u2019ve also started to understand that some process is necessary \u2013 especially for the largest, most risk-averse systems in production.\"}),/*#__PURE__*/t(\"p\",{children:[\"When a company uses Plutora they gain the ability to bridge this gap seamlessly with a tool that can assemble information from the tools developers and project managers use with tools such as BMC Remedy and ServiceNow. When it comes time for your developers to perform a daily or weekly release process they can create accurate CR tickets at the click of a button. Issue and story details from \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/ci-cd-tools/application-lifecycle-management-tools/jira\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"JIRA\"})}),\" or Rally can be configured to flow automatically into a CR ticket and your change management teams can operate with accurate up-to-date information.\"]}),/*#__PURE__*/e(\"p\",{children:\"The choice is simple \u2013 use a tool that can bridge the differences between Agile and ITIL providing change control with an accurate picture of releases or continue down the path of making change management irrelevant.\"}),/*#__PURE__*/t(\"p\",{children:[\"At \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Plutora\"})}),\", we believe that you can have your Agile and practice ITIL-based change management too. You don\u2019t have to accept the inefficient and inaccurate state of change control in your increasingly agile software development organization, and you don\u2019t have to keep on sacrificing a release manager to manage the change control process.\"]}),/*#__PURE__*/t(\"p\",{children:[\"Keeping the systems that manage software development in sync with systems that track changes to production should be as continuous and automated as the \",/*#__PURE__*/e(a,{href:\"https://www.plutora.com/blog/continuous-integration-continuous-delivery-continuous-deployment\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"continuous deployment and integration pipelines\"})}),\" your developers are starting to implement, and no one should have to lie on a CR ticket to work around a broken change management process.\"]})]});export const richText20=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"img\",{alt:\"Server Room Networking Technician\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,8ZrOqV6PPizJxfyYzO8UnSs3Y8.jpg?originalFilename=server-room-person.jpg\",src:\"https://framerusercontent.com/images/8ZrOqV6PPizJxfyYzO8UnSs3Y8.jpg\",srcSet:\"https://framerusercontent.com/images/8ZrOqV6PPizJxfyYzO8UnSs3Y8.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/8ZrOqV6PPizJxfyYzO8UnSs3Y8.jpg 850w\"}),/*#__PURE__*/e(\"p\",{children:\"Almost every large enterprise faces a similar challenge: you\u2019ve moved to cloud-based environments, now how do you achieve some level of elasticity? How do you squeeze more results out of the hardware resources you have? How do you reduce CAPEX for\\xa0testing\\xa0environments?\"}),/*#__PURE__*/e(\"p\",{children:\"Whether you are using a public cloud or a private cloud the ability to dynamically scale resources as needed is the goal.\\xa0 Ideally, your QA environment only needs to exist for a few hours or a few days while a particular project is being tested. Cloud computing coupled with infrastructure automation makes it easy to scale up and scale down resources as needed, and this is how many companies run infrastructure in 2015 \u2013 you scale to meet demand.\\xa0\"}),/*#__PURE__*/e(\"p\",{children:\"For companies investing in third-party clouds this ability to be more \u201Cdynamic\u201D has made it possible for many to shift form CapEx to OpEx and make use of public or shared clouds. Instead of purchasing real hardware (CAPEX) many companies have grown used to capacity on-demand. This isn\u2019t to say that the days of buying hardware are over, the largest companies continue to purchase hardware, but more and more and becoming used to the concept of leveraging third-party clouds.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"The Reality: Throwing Hardware at the Problem\"}),\"That\u2019s the success story of cloud computing.\\xa0 The present reality for non-production environments is another story altogether.\\xa0 Many companies that approach us for help with environment management have long-lived testing and integration environments some of which sit unused most of the time.\\xa0\\xa0 They are running five or six full environments all the time and they are rarely using more than one or two at any given time.\"]}),/*#__PURE__*/e(\"p\",{children:\"Spinning up new environments as needed doesn\u2019t often work in a large enterprise. \\xa0It isn\u2019t a quick process. Databases need to be populated with proper test data, multiple systems need to be configured simultaneously, and for the largest systems in the industry the stars have to be uniquely aligned for an environment to be ready for a test. \\xa0\"}),/*#__PURE__*/e(\"p\",{children:\"Companies will over-provision hardware and run multiple environments because they lack the necessary tools to facilitate planning. \\xa0There\u2019s no central Gantt chart or calendar to track environment availability, and instead of playing \u201Cair traffic control\u201D for environments companies just over-provision. \\xa0At a company not making use of a public cloud this means that teams and making a large capital requests for servers that will sit idle for 90% of the time despite the fact that they are often deployed on a private cloud.\"}),/*#__PURE__*/e(\"img\",{alt:\"Plutora Environment Management\",className:\"framer-image\",\"data-framer-asset\":\"data:framer/asset-reference,s4IHel4hVoHWZ4ACGvINUKsHpHU.png?originalFilename=PL-ENV-43.png\",src:\"https://framerusercontent.com/images/s4IHel4hVoHWZ4ACGvINUKsHpHU.png\",srcSet:\"https://framerusercontent.com/images/s4IHel4hVoHWZ4ACGvINUKsHpHU.png?scale-down-to=512 512w,https://framerusercontent.com/images/s4IHel4hVoHWZ4ACGvINUKsHpHU.png?scale-down-to=1024 1024w,https://framerusercontent.com/images/s4IHel4hVoHWZ4ACGvINUKsHpHU.png 1259w\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Identify Efficiencies and Control Costs with Plutora\"})}),/*#__PURE__*/e(\"p\",{children:\"At some point during the year or the quarter, the business asks teams to submit capital requests for hardware, and the teams that don\u2019t use Plutora continue to ask for more hardware than they need.\\xa0 On some of these projects, this can be a significant expenditure.\\xa0 Over time the business starts to recognize that teams using Plutora are doing more with less. \\xa0This is because the teams using Plutora are able to predict demand and model conflicts and capacity needed to support multiple work streams.\\xa0 Instead of making environment capacity a problem for the budget, project managers and release managers can consult with environment managers on a shared model of capacity.\"}),/*#__PURE__*/e(\"p\",{children:\"When we say that Plutora helps control CAPEX it\u2019s because we\u2019ve seen the result in the customers we\u2019ve worked with. At the largest companies in the industry we\u2019ve seen hundreds of thousands of dollars in capacity saved after environment managers gained simple visibility into how projects and release schedules drive demand. If you are trying to squeeze more out of your IT budgets, Plutora is a quick win. It\u2019ll give your environment managers a view of systems they\u2019ve never had before and it is has been developed to shine a light on waste.\"})]});export const richText21=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"It\u2019s a \u201Cgiven\u201D in software development - release schedules always slip. Requirements shift, developers underestimate timelines, and quality assurance (QA) finds unexpected defects. Another law of software development is that final release dates are often inflexible. If a market or a holiday shopping season defines your release date you understand how important it is to meet a fixed timeline.\"}),/*#__PURE__*/e(\"p\",{children:\"Once you\u2019ve promised a release to the business at the end of the quarter, you are under pressure to deliver software on time and under budget no matter how much your internal timelines have slipped. As a release manager, it is your job to make the best of a challenging situation and to find creative ways to bring a project to an on-time delivery.\"}),/*#__PURE__*/e(\"p\",{children:\"As release deadlines near, IT management is often faced with a series of difficult decisions:\"}),/*#__PURE__*/t(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Do you sacrifice features to meet an inflexible deadline?\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Do you release code with known, but acceptable defects?\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Do you compromise quality and ask QA to rush the testing process?\"})})]}),/*#__PURE__*/e(\"p\",{children:\"Usually, it\u2019s the last question that is answered affirmatively. QA timelines are compressed and QA managers are left with the task of regression testing software releases in a rush to make up for time lost during the development cycle. This \u201Clast-minute\u201D approach to QA testing and verification is an industry-wide practice, and you can recognize it by the number of late-night, last-minute testing sessions that you see at your company.\"}),/*#__PURE__*/e(\"p\",{children:\"To make matters worse, QA is frequently asked to test on shared environments that do not have the correct data to uncover problems in production. QA has to wait for environment setup and teardown that, in turn, leads to even more tightly compressed testing timelines. Compressed QA timelines? Testing on inadequate environments? All of these are recipes for greater production downtime and higher risk to the business.\"}),/*#__PURE__*/e(\"p\",{children:\"How can you avoid these last-minute, late-night approaches to QA? Start by planning your test environments and release schedules in advance.\\xa0\\xa0 QA timelines are often compressed because QA occupies the \u201Ctransition point\u201D between development and production. A development-driven IT department tends to underestimate the amount of effort required to qualify a release for production.\"}),/*#__PURE__*/e(\"p\",{children:\"To protect your QA department from late-night, last minute QA - defend your schedule, organize your test environments, and keep track of your team\u2019s capacity.\"}),/*#__PURE__*/t(\"ol\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Defend your schedule - Create a plan and stick to it:\"}),\" QA shouldn\u2019t just be a passive actor in a release schedule. A QA department should proactively communicate how much time it needs to verify software. If QA needs two or three days to verify a release put this timeline in the schedule and make sure that your release managers understand that this is not flexible. When time is lost during development, don\u2019t let planners try to compensate by stealing it from QA.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Organize your test environments - Reserve QA environments ahead of time:\"}),\" QA and performance testing environments are typically in a state of constant transition with multiple teams competing for resources and databases in various states of readiness. If your project has a fixed timeline plan your environment requirements in advance to make sure that avoidable environment delays do not affect your QA team\u2019s timeline. QA teams often have to wait for databases to be refreshed or environments to be fixed. Such delays can be avoided by giving your environment managers a solution to plan and assign environments alongside release schedules.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Keep track of your QA team\u2019s capacity - Avoid QA burnout: \"}),\"A fact that IT management often forgets is that IT is about people - people who need to sleep, eat, and sometimes take weekends off to relax. If your QA department is being asked to stay up late nights to verify software every single day of the week you are going to suffer from attrition and burnout. You need a solution that can help manage the capacity of your QA staff. One that shows you if there are windows of downtime that present opportunities to shift people between projects rather than asking your team to work at 150% for three week\u2019s straight. Managing your team\u2019s availability becomes more important when software releases become more frequent.\"]})})]}),/*#__PURE__*/e(\"p\",{children:\"Plutora provides solutions to manage test environments, organize your environments, and to keep track of your team\u2019s capacity. Our software has been designed to support the entire IT department and to organize the various teams associated with a software release.\"}),/*#__PURE__*/e(\"p\",{children:\"In our experience, with the largest, most-challenging software releases, the QA department is asked to perform super-human tasks at the tail end of the development cycle. The team is asked to stay up all night to make up for time lost elsewhere, and they are often asked to wait multiple days while databases are refreshed. These problems can be avoided with better management, coordination, and planning and these capabilities are exactly what Plutora provides release managers, environment managers, and QA managers.\"})]});export const richText22=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"As a user of a Project Portfolio Management (PPM) solution, you\u2019re probably hearing about Enterprise Release Management (ERM) as an emerging solution for managing enterprise change and transformation. However, like many others, you\u2019re probably confused about the difference between PPM and ERM. You want to know things like whether or not you can use your existing PPM solution for ERM or, if not, how ERM will work with your existing PPM tool.\\xa0 Here\u2019s a brief overview of what ERM is and how it works alongside PPM to help you better manage your project portfolio.\"}),/*#__PURE__*/e(\"h2\",{children:\"Definitions\"}),/*#__PURE__*/e(\"p\",{children:\"Let\u2019s start by reviewing the definitions of PPM and ERM:\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"PPM\"}),\" gives project managers the ability to manage projects so that expected results are produced. This includes managing scope (features, functionality, performance and quality), time (schedule and production rate) and cost (resources and budget), commonly referred to as the Project Management Triangle. PPM provides a framework for issue resolution and risk mitigation, as well as the centralized visibility to help planning and scheduling.\",/*#__PURE__*/e(\"strong\",{children:\"ERM\"}),\" is the process to govern IT projects and other changes as they go from the development and test environment to the live production environment. In short, ERM manages any change to the IT ecosystem.\"]}),/*#__PURE__*/e(\"p\",{children:\"Now, we're ready to review how PPM and ERM work together as summarized in the following table.\"}),/*#__PURE__*/t(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"\\xa0Project Portfolio ManagementEnterprise Release ManagementIT Outcomes\"}),\"Deliver projects within cost, time and quality constraintsProtect the integrity of production environments and release the correct components\",/*#__PURE__*/e(\"strong\",{children:\"Changes in the IT Ecosystem\"}),\"Collect information related to timing, resources and status across project phasesCollect all changes in the IT ecosystem to avoid resource contention and downtime\",/*#__PURE__*/e(\"strong\",{children:\"Continuous Delivery\"}),\"Deliver projects with multiple releasesReuse release information and artifacts\"]}),/*#__PURE__*/e(\"h3\",{children:\"Meeting IT Outcomes\"}),/*#__PURE__*/e(\"p\",{children:\"While both PPM and ERM aim to successfully release IT outcomes into production, they manage different aspects of this objective. PPM is primarily concerned with planning and coordinating resources required to deploy projects within cost, time and quality constraints.The primary goal of ERM, on the other hand, is to accelerate enterprise software delivery while ensuring that the integrity of the live production environment is protected and that the correct components are released. ERM seeks to provide all stakeholders with visibility and insight into all components of the software release train.\"}),/*#__PURE__*/t(\"p\",{children:[\"ERM combines deliverables of multiple projects/change initiatives that have to be time-boxed or synchronized so that they can be tested and released in a correct sequence based upon their dependencies. By unifying enterprise release architecture and processes, ERM supplements PPM with greater design and processgovernance to improve productivity and reduce change disruption by executing related features as appropriate\",/*#__PURE__*/e(\"em\",{children:\". \"})]}),/*#__PURE__*/e(\"h3\",{children:\"Covering All Changes in the IT Ecosystem\"}),/*#__PURE__*/e(\"p\",{children:\"PPM mostly collects and tracks high-level information related to timing, resources and status across project phases; however, ERM captures broader and more detailed information. This information helps improve PPM\u2019s visibility into changes throughout the release management process which, in turn, increases project management effectiveness. For instance, ERM captures and exposes PPM to all changes in the IT ecosystem so that project managers can identity and avoid resource contention and downtime. Some examples of changes captured by ERM and shared with PPM include maintenance releases, service packs, patches, hot fixes, environment configuration changes, etc.\"}),/*#__PURE__*/e(\"h3\",{children:\"Supporting Continuous Delivery\"}),/*#__PURE__*/e(\"p\",{children:\"Projects managed by PPM and releases managed by ERM have different lifecycles. For example, projects managed by PPM happen once, releases managed by ERM can occur many times. And, while projects come to an end, releases continue in the production environment as either a service or as a service component.\"}),/*#__PURE__*/e(\"p\",{children:\"Because releases are continuous, the natural inclination is to more readily think of benefits from the reusability of information and artifacts in ERM rather than PPM. When a new release is created, development and test teams can save time and money by referring to previous release notes, environment assignments, associated changes and documentation to understand an existing version of the release rather than starting from scratch.\\xa0\\xa0 Although the value of reuse for ERM is more direct, PPM also enjoys these very same benefits because projects are often comprised of multiple releases.\"}),/*#__PURE__*/e(\"h3\",{children:\"Plutora\u2019s ERM Solution and PPM\"}),/*#__PURE__*/e(\"p\",{children:\"Today, enterprise customers across the globe manage $5 billion of releases using Plutora\u2019s ERM solution after discovering that ERM helps PPM fully optimize enterprise software delivery for today\u2019s DevOps and agile development imperatives.\"}),/*#__PURE__*/e(\"p\",{children:\"Plutora integrates with marketing leading PPM solutions, including HP PPM, CA Clarity, Planview Enterprise, and Microsoft Project as well as IT Service Management solutions such as ServiceNow and BMC Remedy and Application Lifecycle Management tools such as JIRA, Rally, and HP Quality Center. Integration with PPM and other tools via adapters or the REST API eliminates the need for manual data reentry and ensures that all data is in synch and accurate.\"}),/*#__PURE__*/e(\"h3\",{children:\"Want to Learn More?\"}),/*#__PURE__*/t(\"p\",{children:[\"Email us (\",/*#__PURE__*/e(a,{href:\"mailto:sales@plutora.com\",openInNewTab:!0,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"sales@plutora.com\"})}),\") to get more information on how ERM and PPM work together.\"]})]});export const richText23=/*#__PURE__*/t(n.Fragment,{children:[/*#__PURE__*/t(\"h6\",{children:[\"Change Management and Release Management are different but related functions within organizations. At a high level, Change activities relate to the process of requesting changes, assessing changes, authorizing changes and reviewing changes. Release activities include planning, designing, configuration, rollout planning, testing communication and deployment. The Release Management function provides the schedule and execution whilst the \",/*#__PURE__*/e(a,{href:\"https://www.bmc.com/blogs/itil-change-advisory-board-cab/\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Change Approval Board\"})}),\" authorizes the change to controlled environments.\"]}),/*#__PURE__*/t(\"p\",{children:[\"Change Management and Release Management are \",/*#__PURE__*/e(\"strong\",{children:\"different\"}),\" but \",/*#__PURE__*/e(\"strong\",{children:\"related\"}),\" functions within organizations.\"]}),/*#__PURE__*/e(\"h2\",{children:\"Change Management\"}),/*#__PURE__*/e(\"p\",{children:\"IT Change Management is primarily concerned with transitioning new initiatives and procedural adjustments\\xa0from development into operations. The objective of change management is to standardize methods and procedures for efficient and prompt handling of all changes in order to minimize the impact of change-related incidents upon service quality, and consequently improve the day-to-day operations of the organization.\"}),/*#__PURE__*/t(\"p\",{children:[\"IT Change Management is the process that governs and introduces\\xa0changes to configuration items (CIs) within the \",/*#__PURE__*/e(a,{href:\"https://searchdatacenter.techtarget.com/definition/configuration-management-database\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"configuration management database\"})}),\" (CMDB) that are part of the organizations live production environment or other environments under change control. Typically IT Operations are accountable for operating and protecting production and staging environments through \",/*#__PURE__*/e(a,{href:\"https://en.wikipedia.org/wiki/Change_control\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"change control\"})}),\". This accountability often stops with production environments.\"]}),/*#__PURE__*/e(\"h2\",{children:/*#__PURE__*/e(\"br\",{className:\"trailing-break\"})})]});\nexport const __FramerMetadata__ = {\"exports\":{\"richText20\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText22\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText1\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText23\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText5\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText6\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText8\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText15\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText16\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText14\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText7\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText10\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText17\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText3\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText18\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText13\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText11\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText19\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText2\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText9\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText4\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText21\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText12\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}"],
  "mappings": "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",
  "names": ["richText", "u", "x", "p", "richText1", "Link", "richText2", "richText3", "richText4", "richText5", "richText6", "richText7", "richText8", "richText9", "richText10", "richText11", "richText12", "richText13", "richText14", "richText15", "richText16", "richText17", "richText18", "richText19", "richText20", "richText21", "richText22", "richText23", "__FramerMetadata__"]
}