OpenStack upgrades and support

OpenStack upgrades are planned around SLURP releases and the roughly 18-month maintained window, tested service by service, and then supported through ongoing operations. This page explains what that work includes, what drives its cost, and what your team must provide.

On this page

Who needs OpenStack upgrade and support, and when to hand it to a partner

Most OpenStack operators keep upgrade decisions and day-to-day ownership in-house, and many hand part of the planning, testing and runbook work to a partner. The question is less whether a partner is needed at all and more which of those tasks your own team can carry at the pace your release calendar demands. This section helps you decide which group your cloud falls into and what to check before that decision is made.

The usual triggers are approaching end of the maintained phase for your current release, a skipped release that leaves you several steps behind the one you need, a published security advisory that affects a service you run, and staff turnover that removes the people who understood your deployment. OpenStack stable branches are maintained for approximately 18 months, and after that only SLURP releases may enter an unmaintained phase, so the release you run dictates how much time you have. Check the current status of your release on the OpenStack releases site before you set any internal deadline.

A useful first step is an inventory of what you actually run: the release number, the deployment tool (Kolla-Ansible or OpenStack-Ansible), the services enabled, the Ceph release backing Glance, Cinder and Nova, and the Keystone federation and mapping rules in place. Without that inventory, neither your team nor a partner can scope an upgrade or estimate its effort. Ask who holds the current inventory and whether the configuration lives under version control.

Teams that stay in-house usually have at least one engineer who has performed a release upgrade in a lab, a named owner for the upgrade calendar, and a tested rollback path for the control plane and database. Teams that hand off often lack one of those three, or they have too many upgrades queued at once to test each service properly. Partners typically carry the upgrade plan, per-service test matrix, change records and operational runbooks, while your team keeps approval authority, change windows and production access.

Before you sign anything, confirm in writing who owns each decision, who runs each test, what happens when a service fails in the middle of an upgrade, and what your staff must learn to operate the cloud afterwards. Ask any partner how their work is scoped and quoted, which tasks recur and which are one-time, and how on-call coverage is handled outside business hours. Clear answers to those questions tell you whether a partner adds capacity or simply adds another party to coordinate.

What an OpenStack upgrade and support engagement includes

An OpenStack upgrade and support engagement moves through a fixed sequence: assess the current estate, plan the release path, rehearse each service, cut over in a controlled window, validate, and then keep the cloud patched and supported. Each package produces a document or artifact the client keeps, and the scope, deliverables and timelines are agreed in writing before work starts.

Current-state assessment

We inventory the running OpenStack release, the deployment tool version (Kolla-Ansible or OpenStack-Ansible), and the versions of each service, database, message queue and Ceph component where storage is integrated. We check each component against the maintained-phase release list and flag anything in an unmaintained or end-of-life state. The client receives a written assessment with a version matrix and a list of configuration drift found in the inventory and configuration repositories.

Upgrade path planning

We map the route from the current release to a target release, choosing between a SLURP-to-SLURP jump and a step through adjacent releases based on the release cadence and the 18-month maintained window for stable branches. The plan lists the order of service upgrades, prerequisite configuration changes, and any deprecated options that must be removed first. The client receives a written upgrade plan that the change advisory board can review before any environment is touched.

Per-service test plans and staging rehearsals

Each in-scope service gets its own test cases covering API behavior, Keystone authentication, image and volume operations, and instance lifecycle actions. We rehearse the full upgrade in a staging environment built from the production configuration, record the duration and every manual step, and fix the runbook until it runs without improvisation. The client receives tested runbooks, the per-service test results and a log of issues found during rehearsal.

Production window and rollback plan

We agree the change window with the client, define go and no-go checkpoints between each service upgrade, and document the rollback path for each step, including database backups and the configuration state to restore. Rollback decisions are tied to measured failure conditions named in advance, not decided during the outage. The client receives a change plan with named roles, communication steps and a rollback runbook approved before the window opens.

Post-upgrade validation

After the cutover we run the validation suite against production, confirm that Keystone federation and mapping rules still resolve users to the expected projects, and check that Glance, Cinder and Nova can still reach their backends, including Ceph where it is in use. We compare post-upgrade service versions with the plan and confirm that no tenant workload was left in an error state. The client receives a validation report and a dated change log of every version and configuration change made.

Ongoing support scope

Support covers patching within the maintained branches, monitoring of control plane and compute health, incident response within the agreed hours, and regular verification that backups can be restored. We confirm the scope of each item in writing, including which systems are covered and who the escalation contacts are. The client receives a handover document with operating procedures, on-call contacts and a patch calendar. Ongoing support is available as a retainer.

What drives the cost and duration of an OpenStack upgrade

This table lists the factors that move the cost and duration of an OpenStack upgrade, why each one matters and how to keep it down. Read each row as a lever: most upgrades grow in effort when several drivers rise together, so compare your environment against every row before requesting a quote. Use the last column to decide where to invest in preparation before work starts.

DriverWhy it mattersHow to keep it down
Services enabled and their customizationsEach enabled service has its own configuration, database schema changes and test cases. Heavily customized services need more regression testing and more time to reconcile local changes with each release.Enable only services in use, document every deviation from defaults, and keep overrides in the deployment configuration rather than in patched service code.
Deployment tool (Kolla-Ansible or OpenStack-Ansible)Kolla-Ansible upgrades replace container images, while OpenStack-Ansible on LXC or bare metal changes packages and container layouts. Each path has its own playbooks, rollback behavior and failure modes.Confirm the tool and version with the vendor documentation for your target release, and keep inventories and group variables under version control so the upgrade replays the same way in every environment.
Number of hypervisors and workload densityMore compute nodes mean longer rolling upgrades, more live migration or evacuation work and more hosts to verify after each step. Density affects how much capacity remains while nodes are drained.Plan rolling batches by spare capacity, automate host draining and verification, and record per-host checks so a failed batch can be isolated quickly.
Ceph storage on the same platformCeph adds a separate upgrade sequence for monitors, managers, OSDs and gateways, with its own health gates. Storage upgrades usually have the strictest rollback requirements because data is involved.Confirm the Ceph release compatibility with your target OpenStack release, upgrade Ceph in its documented order, and schedule storage changes with explicit health checks before and after each stage.
Number of environments upgraded in order (lab, staging, production)Each environment repeats the full sequence and any defects found in one must be fixed before the next. Production timing depends on how many gates sit between environments.Build a lab that mirrors production hardware classes and integrations, and reuse the same automation in every environment so each promotion is a repeat of a tested run.
Identity integrations such as Keystone federationFederated identity providers, mapping rules and Keystone-to-Keystone trust each need re-testing after an upgrade. Login failures often appear only with real user accounts and group claims.Inventory every identity provider, mapping rule and trust relationship before planning, and create test users for each group and project mapping that must keep working.
Number of hops between releasesUpgrades are supported between adjacent releases and between SLURP releases. Skipping intermediate releases that are not SLURP means more schema and configuration steps to apply in sequence.Confirm the supported upgrade path for your current and target releases in the release documentation, and plan the path before scheduling any environment.
Custom out-of-tree code and Heat templatesPatches, custom drivers, scheduler filters and Heat templates may break when upstream APIs or defaults change. Each item needs analysis, rework and testing.Keep custom code in maintained, reviewed repositories, track upstream changes against each release, and remove patches that upstream code now provides.
Compliance evidence the change must produceChange records, test results, configuration baselines and sign-off records extend the work beyond the technical upgrade. Scope depends on which controls your assessor expects to see evidenced.Agree the evidence list with your assessor or compliance lead before the upgrade starts, and generate test output, configuration diffs and approval records from the same runs that perform the change.

The phases of an OpenStack upgrade project and what each one produces

The sequence moves a cloud from its current release to a chosen target through discovery, planning, testing, rehearsal, a controlled production change and handover. Each phase ends with a written artifact the client keeps, so the next phase starts from evidence rather than memory.

  1. Discover and inventory the current cloud

    The partner records the running OpenStack release, the deployment tool (Kolla-Ansible, OpenStack-Ansible or another method), every enabled service, hypervisor and storage backends, Ceph pools, identity integrations such as Keystone federation, and the configuration and inventory files kept under version control. The client receives an inventory document and a list of open questions, such as custom patches or unsupported plugins. The step is done when the client confirms the inventory matches what runs in production.

  2. Select the target release and upgrade path

    Using the inventory, the partner and client agree the target release and the sequence of intermediate hops, checking which releases are in the maintained phase and whether a SLURP release fits the client's support horizon. The output is a written upgrade path decision that names the target, the hops, the reasons for each and the release dates the client has to plan around. Clients should confirm the release dates against the OpenStack releases site when the decision is signed.

  3. Write the per-service test plan

    Each enabled service, including identity, compute, networking, block storage, image and dashboard components, gets its own test cases, pass criteria and rollback trigger. Cases cover API smoke tests, tenant workflows, integrations and the storage paths between Glance, Cinder, Nova and Ceph. The client receives a test plan with named owners for each service and a defined set of acceptance criteria. The plan is complete when the client signs off that every production-relevant workflow has a test.

  4. Rehearse the upgrade in lab or staging

    The partner runs the full upgrade path against a lab or staging copy built from the inventory, executing the runbook step by step and timing each action. Defects, ordering problems and configuration drift found during rehearsal are fixed and the runbook is revised. The client receives the rehearsal log, the revised runbook and a list of residual risks. The rehearsal is complete when a clean run passes the test plan and the client gives a go or no-go decision in writing.

  5. Execute the production change with rollback

    Within the agreed change window, the team takes verified backups, confirms rollback points for the control plane and databases, and runs the approved runbook hop by hop. Each hop has a checkpoint where the change owner decides whether to continue or roll back. The client receives a change record listing every action, the timestamps, the checkpoints passed and the backup verification results. The step is done when all hops complete or the documented rollback path has been executed and recorded.

  6. Validate the cloud after upgrade

    After the change, the partner reruns the per-service test plan against production, compares performance and error baselines with pre-change figures, and checks sample tenant workloads end to end, including boot from Ceph volumes and federated logins. The client receives a post-upgrade validation report showing each test result and any deviations with their disposition. Validation closes when the client accepts the report and the cloud is released back to tenants.

  7. Hand over into ongoing support

    The partner delivers updated architecture and runbook documentation, the final inventory, the changed configuration repository and a record of decisions made during the project. The parties agree which operations stay with the client's team and which fall under a support or retainer arrangement, and they set the next upgrade review date. The client receives a handover pack and a written support scope. Handover is complete when the client's operators run a routine task from the new documentation without assistance.

How SLURP releases and the 18-month window shape an upgrade plan

The first planning decision for an OpenStack upgrade is which release you are moving to, and that choice depends on how OpenStack releases are scheduled. OpenStack has historically shipped on a six-month cycle. Since the 2022 cadence change, the community supports upgrades between SLURP releases as well as between adjacent releases, so a cloud does not have to step through every release in between. SLURP releases are the ones the project designates for longer-term upgrade paths, and they are the releases to plan around when you want fewer upgrade hops.

The maintained window is the second constraint. OpenStack stable branches are maintained for approximately 18 months. After that, only SLURP releases continue into an unmaintained phase, where the project publishes no further releases and runs reduced CI, before end of life. A release that has left the maintained window is not a safe place to park production, because security and bug fixes will stop arriving through the normal stable process. Your upgrade plan should therefore check, for each candidate target, whether it is still maintained when you expect to finish the work and when you expect to need the next upgrade.

The releases named in current planning material are 2025.1 Epoxy, 2025.2 Flamingo, 2026.1 Gazpacho (a SLURP release), 2026.2 Hibiscus, and 2027.1 Indri, which is in development with an estimated release date of 2027-03-24. Status changes as the calendar moves, so confirm each release's current phase on the OpenStack releases site on the day you start planning. Do not rely on a status copied from an older document, a vendor deck or this page. Record the phase, the release date and the estimated end of maintenance in your upgrade design document, with the date you checked them.

In practice, choose a target SLURP release where the upgrade path allows it, and check that the path from your current release to that target is supported by the release notes and upgrade documentation for each service you run. Each release you skip is additional testing: it adds configuration changes, database migrations and API behavior changes that your test environment must exercise. Ask your partner or internal team to estimate how many intermediate releases each option would require and what testing each step needs, and ask for those estimates in writing so you can compare options on evidence rather than on release names alone.

What usually goes wrong in OpenStack upgrades and how to prevent it

Most OpenStack upgrade failures trace back to a few causes: the upgrade path, untested changes, and configuration that no one tracked. Each card names one failure mode and the step that prevents it, so the upgrade plan can be checked item by item before a maintenance window is booked.

Skipped steps and the maintained window

Upgrades are supported between adjacent releases and between SLURP releases, so the path has to follow the documented order for each hop. Stable branches are maintained for approximately 18 months, and after that only SLURP releases enter an unmaintained phase. Check the planned path against the OpenStack releases site, confirm that the deployment tool version supports the target release, and schedule the next hop before the current release leaves its maintained window.

Upgrades without production-like rehearsal

A staging run on empty databases hides the failures that matter. Restore a recent copy of the production database and a representative set of instances, images and volumes into an isolated environment, then run the full upgrade and time each database migration. Long migrations on large tables are easiest to find in rehearsal, where the maintenance window can be planned from measured runtime. Run per-service tests afterward for compute, block storage, image, networking and identity, and keep the results as a baseline for production.

Configuration drift between inventories

Kolla-Ansible and OpenStack-Ansible deployments depend on inventories, group variables and service overrides. When production, staging and the rehearsal environment diverge, a change that passes in one can fail in another. Keep inventories and configuration files in version control, tag the state before each upgrade, and compare running configuration against the repository on a schedule. Ask how manual changes made outside the pipeline are recorded and who approves them.

Out-of-tree patches and dashboard customizations

Patches applied to service code, custom Heat resource plugins and Horizon panels or themes are often the first components to break after a release. Inventory every local change, record the reason it exists, and check whether upstream now provides the same behavior. Keep each customization in its own tested package, run its tests against the target release before the upgrade, and remove patches that are no longer needed. Changes kept close to upstream are easier to re-apply after each hop.

Ceph version mismatches with Glance, Cinder and Nova

Glance, Cinder and Nova reach Ceph block devices through their own client configuration, so a Ceph release can fall out of step with the OpenStack release. Confirm which Ceph releases the target OpenStack release supports in the Ceph and OpenStack documentation before changing either side. Upgrade in a planned order, verify client authentication and pool permissions for each service, and test image upload, volume attach and boot from volume after each step. Keep a tested rollback for the storage path.

Identity policy changes that lock out users

A new release can change default Keystone policy or the way federation mapping rules evaluate attributes from your identity provider. Users who had access may lose it, and administrators may lose the API access they need to fix the problem. Compare old and new policy files before the upgrade, test each role and federated login path with dedicated test accounts, and keep a break-glass administrator outside the federation path. Confirm that mapping rules still match the groups and attributes your identity provider sends.

What recurring OpenStack support costs after the upgrade

The upgrade itself is a finite project, but running an OpenStack cloud afterwards creates recurring cost lines that should be budgeted before the first upgrade is signed off. The largest of these is ongoing support, usually billed as a retainer with a set number of hours or as a monthly service level agreed in writing. Support covers triage of tickets against the control plane, Nova, Neutron, Cinder, Glance and Keystone, and the response to failed live migrations or stuck instances. Ask whether the retainer includes on-call coverage outside business hours, and what counts as an incident versus a change request.

The second recurring line is the upgrade cycle itself. Each time you move to a new release, the work repeats: release notes review, configuration changes for the Kolla-Ansible or OpenStack-Ansible deployment, staging rehearsal, service-by-service testing and a production run. Whether you move from one SLURP release to the next, or step through adjacent releases, changes the number of cycles across a given period. The stable branch of each release is maintained for approximately 18 months, so an upgrade plan built around the maintained window needs a dated decision on which release to target next. Ask the partner to state the release path in the quote, including the releases skipped and the testing each step requires.

Patching within maintained branches is a smaller but steady line. Minor updates to the chosen release, along with container image rebuilds, dependency updates and host operating system patches, need test runs in staging before production. Monitoring and backup verification also recur. Someone must review alert thresholds, confirm that Ceph or other storage backups restore successfully on a schedule, and record the results. These tasks are easy to underestimate because they produce no visible change when they succeed, so put them in the scope as named activities with a frequency rather than as general support.

Staging and test environments carry a cost that many budgets omit. A usable rehearsal environment needs compute, storage and network capacity close enough to production to surface real problems, along with the power, cooling and rack space to host it. Your data center team should confirm these costs in its own accounts, since they depend on your facilities. Internal engineers also carry recurring cost: they review changes, approve maintenance windows, respond to incidents and maintain the knowledge needed to operate the cloud between partner engagements.

DeployOpen does not publish a price list. Retainers and fixed-scope upgrades are quoted from the written scope, and the one-time work (initial assessment and rehearsal) is priced separately from recurring support. When you request a quote, ask for the release path, the response expectations agreed in writing (including severity levels and hours covered), the testing scope for each service and the handover package, meaning the runbooks, configuration under version control, test results and rollback steps your team keeps after the engagement ends.

How the upgrade work differs by starting point

Kolla-Ansible runs OpenStack services in Docker containers driven by Ansible, so the upgrade path runs through the container images and the playbooks that pin them. Planning starts with the image set and the inventory. Rollback depends on keeping the previous images and configuration available until the new release is verified.

  • Planning: Confirm which Kolla-Ansible version targets your source and target releases, and whether it supports the upgrade path you intend to take.
  • Testing: Rehearse the upgrade on a copy of the control plane that uses the same globals and passwords files. Compare service health before and after, service by service.
  • Rollback: Keep the previous image tags in your registry and the prior configuration under version control, so the earlier containers can be redeployed.
  • Release notes: Check for required upgrade steps, deprecated options and changes to database migration order in the target release.

Confirm the Kolla-Ansible release notes for your source and target versions before you pin any image tags.

What your team must provide before an upgrade or support engagement starts

The first requirement is access to the source of truth for your cloud. Your team needs read and change access to the deployment repository, whether it holds Kolla-Ansible or OpenStack-Ansible code, along with the inventories, global settings and per-host overrides that produce the running control plane and compute nodes. Everything should sit under version control. Before the engagement starts, ask whether the repository matches what is deployed on each controller, network node and hypervisor. Any drift found at this stage, such as a hand-edited configuration file on one host, must be recorded and resolved, because an upgrade run from the repository will not reproduce a change that only exists on a server.

Next, provide a current backup and a restore test record. A backup file alone does not show that the cloud can be rebuilt. The record should cover the Keystone, Nova, Glance, Cinder and Neutron databases, the Glance images, the Cinder volumes and backups, and the Ceph pools that hold them if Ceph is part of the design. For each item, the record should show the date of the last successful restore test, who ran it, the scope tested and the time taken. If no restore test has ever been run, make that the first task, carried out in staging before any upgrade planning continues.

Your team must also provide a staging environment that resembles production. It should run the same OpenStack release, the same hypervisor and Ceph versions where possible, a comparable network segmentation design and enough spare compute to evacuate representative workloads during testing. Confirm the staging capacity in writing, since a smaller staging cloud will pass tests that production would fail. In addition, name one accountable owner each for compute, storage, network and identity. These owners must be able to approve changes in their area and to answer questions during the work without waiting for a committee.

Finally, your organization must make three decisions and record them. First, agree the target release. Upgrades are planned between releases, and the choice of target determines the test scope and the length of the maintained window that follows. Second, define the acceptable downtime for tenants, including whether instances may be live migrated, stopped or must stay fully available. Third, set up a change approval path and a set of maintenance windows. A partner can recommend a window and a rollback point, but your organization owns the business decisions on timing and on which risks to accept. Those decisions should be signed off by the people who carry the consequences of an outage.

Questions buyers ask before hiring outside help for OpenStack upgrades

Can our own team upgrade OpenStack without outside help?

Yes, if your team has the OpenStack skills and enough time to test each service before production. The upgrade is a sequence of steps per service, deployment tool and release, so the hardest part is usually verification. Your team needs to confirm that APIs, Keystone federation, storage backends and tenant workloads behave the same afterwards. Teams that already run Kolla-Ansible or OpenStack-Ansible know their tooling, which shortens the path. Teams that have not upgraded before should plan a staging environment that mirrors production and time for a rehearsed rollback. Ask any provider to walk through the same checklist so you can compare effort on equal terms.

What drives the cost and effort of an OpenStack upgrade?

Scope, complexity and test depth drive most of the cost. The main factors are the number of services and features enabled, the deployment tool, how far your configuration has drifted from defaults, the number of releases crossed, and the size of the control plane and compute fleet. Identity federation, Ceph or other storage integrations, and custom policies or code each add test work. Most of the cost is labor: assessment, staging build, per-service testing, the production window and documentation. The upgrade itself is one-time work, while the maintenance cadence that follows recurs. In a quote, ask for scope by service, the environments included, the test evidence delivered and how a finding that changes the plan is handled. A quote follows from written scope.

How long does an OpenStack upgrade usually take?

Duration depends on the same drivers as cost, so no single figure fits every environment. Length is set by the number of releases crossed, how many services and integrations need testing, whether a staging environment exists, the size of the fleet that must be drained or restarted, and how many approval gates your change process requires. Assessment and test planning usually run ahead of the production window, and the window is most sensitive to fleet size. Ask for a duration tied to a written scope and an agreed environment list. Your schedule should also account for the maintained-window dates of the release you are leaving and the one you are moving to.

What does an OpenStack upgrade need from our team?

It needs named people, access and current records. Typical inputs include an inventory of control plane and compute nodes, the current deployment configuration under version control, documented Keystone mappings and Ceph pool layouts, a staging environment, and recent backup and restore evidence. Your operations and security teams approve change windows, and someone must decide on tenant impact. Your team also owns tenant communication and any workload that needs application-level validation. Arrange access to deployment hosts, repositories and monitoring before work starts. If configuration lives only on one engineer's workstation, the assessment phase will take longer.

Can you skip OpenStack releases during an upgrade?

Supported upgrade paths run between adjacent releases and between SLURP releases, so the planning question is which SLURP release to target. Stepping from a non-SLURP release usually means moving through intermediate releases, each with its own testing. Jumping over several releases adds risk because service changes, configuration options and deprecations accumulate. Map the path from your current release to the target, read the release notes for each step, and confirm the sequence of services and database migrations in your deployment tool's documentation. Compare a longer path with a staged path against your change calendar. Confirm the exact supported path for your versions in the release documentation before you commit to a plan.

What happens when our OpenStack release leaves the maintained window?

Stable branches are maintained for approximately 18 months, after which routine fixes stop. Under the project's policy, only SLURP releases may enter an unmaintained phase, where no further releases are made and CI is reduced, before end of life. Other releases do not get that phase. For you, security and bug fixes then depend on upstream timing or on what your provider supports, so upgrade planning should begin before the window closes. Check the current status of each version you run on the OpenStack releases site, and confirm with your provider what they support on unmaintained branches.

Does DeployOpen certify or audit our OpenStack upgrade?

No. DeployOpen does not issue audit reports, attestations or certifications. It can prepare systems, configuration records, test evidence and change documentation that your internal reviewers or independent auditors can assess, if your compliance program needs them. Certification or audit comes from the relevant independent body, which sets the scope of its own assessment with your organization. Ask the assessor which evidence it expects before the upgrade starts, so tests and records are captured while the work happens and are not rebuilt afterwards.

How does ongoing OpenStack support differ from a one-off upgrade?

A one-off upgrade is a scoped project with a start, a finish and a handover. Support is recurring work that can cover monitoring, patching within maintained branches, incident response, upgrade planning and configuration changes over time. Most engagements are fixed-scope, and ongoing support, upgrades and continuous testing are available as retainers. Project work is priced from written scope, while support is usually recurring, so compare the hours, the environments covered and the response arrangements. Ask what the retainer includes, how upgrades are scheduled against the maintained window, who approves changes and how evidence is recorded. Support shares the operating load with your internal team.

How DeployOpen scopes, delivers and supports OpenStack upgrades

DeployOpen plans, upgrades, tests, documents and supports OpenStack inside your own data centers or cloud accounts. Each engagement starts with a written scope that ties the upgrade path to SLURP releases and the roughly 18-month maintained window for stable branches. Most engagements are fixed-scope, so deliverables and timelines are agreed in writing before any upgrade begins. Support can continue after handover as a retainer.

How we scope

  • The written scope names source and target OpenStack releases, including whether the path runs between SLURP releases.
  • It lists every service in the upgrade, such as Keystone, Nova, Glance, Cinder, Neutron and Ceph integrations.
  • Deployment tooling is confirmed up front, whether Kolla-Ansible or OpenStack-Ansible, since the steps differ by tool.

How we build

  • Upgrades are rehearsed on a non-production copy of the cloud before any change reaches production.
  • Testing runs per service, covering API behavior, Keystone authentication, Ceph-backed volumes and instance boot.
  • Rollback steps and go/no-go checks are written and agreed before the maintenance window opens.

How we hand over

  • Handover includes the upgraded configuration, inventories and runbooks, kept under version control in your environment.
  • Upgrade notes record each service's changes, known deviations and the checks your team should repeat next cycle.
  • Your operators receive a walkthrough of the upgrade so they can run the next SLURP path with confidence.

How we support

  • Ongoing support is available as a retainer, and its covered tasks are set out in the written agreement.
  • Upgrade planning tracks the next SLURP release and flags when your current branch nears end of maintained life.
  • Ask for response expectations, named contacts and testing cadence in writing before you sign.

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.