In DevOps, accelerating flow is critical for delivering value faster. One important metric is Mean Time to Approve (MTTA) - how long it takes to get a release approved and verified as ready for production. For ServiceNow, this translates to the time from an update set being marked complete until it passes all tests and checks and is approved for deployment.
Why does this matter? Faster approval means faster deployment, which translates to more rapid value delivery. Optimizing MTTA is critical for efficient flow. MTTA specifically measures the duration between when all update sets and apps for a release are finished and when it passes all the checks and approvals to be verified production-ready. Optimizing MTTA includes activities like:
- Running automated test suites
- Scanning for security vulnerabilities
- Manual code reviews and peer approvals
- UAT testing and user signoffs
- Security and compliance checks
MTTA ends when all necessary validations are completed and the required approvers have signed off on the release. A shorter MTTA indicates you have optimized the verification process by removing bottlenecks, increasing visibility, and leveraging automation.
What techniques can help improve MTTA?
First, automate manual processes wherever possible - especially repetitive checks like testing and scanning. Automated checks/gates reduce human workload and speed up validation.
Second, ensure visibility across your ServiceNow landscape. Make instance inconsistencies transparent to all stakeholders and full traceability details - who, what, where, when, and how.
Third, mandate approvals only where necessary. Don't force signoffs without value — trust automation for repeatable checks. Reserve human reviews for assessing business impact and mitigating risk.
Fourth, validate and deploy frequently in smaller batches. Get feedback early to avoid production release surprises. Bulk or batch production releases extend MTTA.
Finally, foster collaboration between teams. Alignment and shared ownership of your ServiceNow landscape is vital for improving flow.
Optimizing DevOps Flow MTTA with xtype
xtype provides a way to optimize this flow and shorten MTTA for ServiceNow. xtype Deployment Flows define the automation and steps in migrating update sets and applications between instances. Under the covers, xtype is utilizing native ServiceNow automation mechanics leveraging the platform features you know and trust. xtype Deployment Flows let you insert additional tasks like ATF executions, code scans, and manual approvals. xtype Deployment Flows bake your quality and approval gates directly into the deployment pipeline, ensuring constant compliance with your approved processes.
For example, consider an update set moving from a DEV instance to QA. An xtype Deployment Flow may look like this:
- Developer marks update set complete in DEV.
- The ATF test suite runs against the update set in QA.
- If the ATF is successful, then a code scan is run.
- Approvers are notified that the tests passed and the scans are clean.
- Approvers manually approve the update set for deployment to QA.
- The update set is migrated to QA.
This flow allows us to automate steps like testing and scanning. Approvers can easily see the results and give manual approval to proceed. We've shortened the human approval time by handling the preparation automatically. The key is a well-defined flow matching your update set or application's needs, practices, and procedures.
Impact of xtype on ServiceNow MTTA
xtype Deployment Flows provides:
- Automation to reduce human errors and wait time
- Traceability for update set and app propagation
- Policy enforcement for governance and compliance
- Accelerated velocity with safety
- Practicing the Principle of Least Privilege (PoLP)
- Bidirectional synchronization eliminates multi-instance inconsistency and thus improves velocity, quality, and frequency
Because xtype handles the mechanics of change synchronization and deployment automation, developers no longer need elevated access to non-development instances. Additionally, preview errors are shifted left where developers can resolve them as they develop apps and features rather than troubleshoot them days or weeks later in downstream instances.
Shifting preview errors left also means that new features and apps are migrated downstream to production with a higher probability of success and error-free deployments. Without xtype Controlled Synchronization, features and apps are built with errors unintentionally baked in. This is because developers build features and apps without the same plugins, updates, or ServiceNow version in downstream instances like QA and production.
In today's world, delivering ServiceNow value faster matters. With xtype, you can transform MTTA for ServiceNow delivery - optimizing for speed while retaining control. With xtype, you may be surprised how much you can improve your Mean Time to Approve.