Browse the Knowledge Hub211 resources
ALM / Quality Center review: pricing, alternatives and setup
ALM/Quality Center, now sold by OpenText as Application Quality Management, is an enterprise platform for releases, requirements, test plans, test execution and defects, with traceability between them. ALM Octane, now documented as OpenText Software Delivery Management, is its web-based sibling for agile and DevOps teams, adding backlog planning, CI pipeline integration and an API that turns automated test results into tests and runs.
QAble has evaluated this tool and works alongside it. The factual sections are complete; our view is bounded to what we have actually seen rather than a long-term verdict.
- last reviewed
- 13 October 2026
- version covered
- OpenText Application Quality Management 26.1 and Software Delivery Management 26.3
- licence
- Commercial
At a glance
ALM / Quality Center at a glance
- Vendor
- OpenText
- Category
- Test management
- Licence
- Commercial
- Platforms
- Self-hosted, Cloud
- Integrates with
- UFT, LoadRunner, Jenkins, Jira
- First released
- 2002
- Version reviewed
- OpenText Application Quality Management 26.1 and Software Delivery Management 26.3
Verdict
Our verdict on ALM / Quality Center
Strengths
- Requirements, tests, runs and defects linked in one system, which is what auditors ask for
- Mature manual test design and execution with test sets, cycles and releases
- Software Delivery Management creates tests and runs automatically from posted CI results
- Off-cloud and public-cloud deployment for both products, for data residency needs
- Long-standing integration with OpenText UFT One and the wider OpenText testing suite
Weaknesses
- No public pricing; editions and tiers are sold through OpenText sales
- Renamed products mean documentation and forum answers use several names at once
- The Application Quality Management desktop client downloads Windows components using .NET and COM
- Heavier to administer than Jira-based tools, especially on-premises
Our take
These products persist in regulated enterprises because traceability from requirement to test to defect is an audit artefact there, not a convenience, and auditors know how to read it. Few teams choose Application Quality Management fresh today; most meet it alongside an existing UFT One estate, and the realistic questions are how to feed modern automation into it and whether to move to Software Delivery Management. QAble has evaluated both rather than administered a long-running instance, so treat this as a bounded take. Watch the naming: OpenText documentation, URLs and community forums still mix ALM, Quality Center, Octane and the new names, so search with all of them. Pricing is quote-only, so compare total cost against Jira-based tools early, including administration and upgrades for on-premises installs.
We have evaluated this tool rather than maintained a long-running suite on it, so this is a bounded view rather than a long-term verdict. The rest of this page is factual.
How it works
How ALM / Quality Center works
Two products from one lineage
OpenText inherited two related products from Micro Focus. ALM/Quality Center, the older one, is now sold as OpenText Application Quality Management, with Express, Enterprise and ALM editions; its help centre is at version 26.1. ALM Octane, built later as a web application for agile teams, is now documented as OpenText Software Delivery Management, at version 26.3, sold in Premium and Ultimate tiers with a Developer add-on. Both remain available, and the Application Quality Management help points customers who want to modernise towards Octane. The names matter in practice, because help centre addresses, community spaces and older articles still use ALM and Octane.
Application Quality Management under the hood
Application Quality Management is a Java EE application served by its own application server, which runs on Windows or Linux. Data sits in Oracle or Microsoft SQL Server: one site administration schema for users, domains and settings, plus a separate schema for every project, with attachments and other files in a project repository on disk. When users open the classic client, components are downloaded to their machine and talk to each other through .NET and COM, which is why that client is Windows-bound; a browser-based Web Client is also available, and the 26.1 release notes list a run of enhancements for it. Per-project schemas explain both its strength, isolated projects, and its weakness, cross-project work that needs extra tooling.
The lifecycle the modules enforce
Application Quality Management organises work as a fixed lifecycle. You define releases and cycles, then requirements describing what must be achieved, then tests in the Test Plan module, linked to requirements through coverage. In the Test Lab module you group tests into test sets and run them, manually or through automation tools such as UFT One. Failures become defects in the Defects module, linked back to the run, test and requirement. Reports and graphs read across all of it. The structure is the product: it makes coverage and traceability questions easy to answer, and it makes lightweight, exploratory or code-first working feel heavy.
Software Delivery Management’s spaces and test ingestion
Software Delivery Management is a web application organised into shared spaces, which hold users and shared settings, and workspaces, which hold a team’s or product’s backlog, tests, pipelines and defects. Automated testing connects through CI integrations and a test-results REST resource. A CI job posts an XML payload of test runs; the server validates it against an XSD, processes it asynchronously, and creates or updates automated tests and runs. A test is identified by its component, package, class and name, so the same identity on the next build updates the existing test’s run history instead of creating a new test.
Strengths
What it does well
Traceability built for audits
Coverage links between requirements and tests, and links from runs to defects, let either product answer which requirements are tested, which failed and what defects block a release. In regulated industries this report is often the deliverable, and producing it from a single system is the main reason these tools remain in place.
Libraries, baselines and version comparison
Application Quality Management 26.1 brings libraries and baselines to the Web Client, so reusable content can be captured, compared over time and imported across projects. Requirements and tests can now be compared version to version from their history. Both matter where a validated test set must be frozen and compared before each release.
Automated results that create their own tests
In Software Delivery Management, posting results creates automated test entities if none match, links them to releases, backlog items, application modules and environment labels from the payload, and keeps a last-run history per combination of release, milestone and environment. Teams get coverage reporting for automation without hand-creating a test per method.
Pipelines from CI servers
Software Delivery Management connects to CI servers such as Jenkins and GitHub Actions through OpenText-supplied integrations, showing pipeline runs, test results and the commits behind them, and can trigger on-demand automated test runs. That ties automated quality signals to the backlog items they cover.
Dashboards and AI assistance
Release 26.3 of Software Delivery Management adds scripted JavaScript dashboard widgets and dynamic filters shared across widgets, and extends the DevOps Aviator assistant with knowledge sources scoped to particular workspaces or entities. These are useful for programme-level reporting, though they are new and best piloted on one workspace first.
Pricing
ALM / Quality Center pricing and licensing
Both products are commercial and quote-only: OpenText publishes no list prices, and the product pages lead to contact and demo requests. Application Quality Management is sold in Express, Enterprise and ALM editions, each available off cloud or in the public cloud. Software Delivery Management is sold in Premium and Ultimate tiers with an optional Developer add-on, with an off-cloud option. Budget for administration as well as licences, especially for on-premises installs with their own databases.
- Licence: proprietary, sold by OpenText; prices are not published on the product pages, which offer a demo or a sales contact.
- Application Quality Management editions: Express, Enterprise and ALM, with off-cloud and public-cloud deployment listed for each.
- Software Delivery Management tiers: Premium and Ultimate, plus a Developer add-on, with an off-cloud option for both tiers.
- Free options: no free tier; the Application Quality Management page offers an interactive click tour, and both pages offer demos.
- Hidden costs: database servers and administration for off-cloud installs, upgrade projects between versions, and integration work with Jira and CI.
Checked against the vendor’s own pages on 13 October 2026. Pricing changes; confirm on the official site before buying.
Getting started
Getting started with ALM / Quality Center
Setup, step by step
- Ask your space admin for an API access key pair, a client ID and client secret, in the shared space’s API Access settings.
- Find your shared space ID and workspace ID from the workspace URL or the admin settings.
- Sign in to the REST API with the key pair and keep the LWSSO_COOKIE_KEY cookie it sets.
- Fetch the payload XSD from the test-results resource and validate a small payload against it.
- POST the payload, then poll the task ID until it reports success, and find the new tests in the workspace.
Install
# No client install for the REST API: curl or any HTTP client will do.
# The API base is https://<server>/api/shared_spaces/<space_id>/workspaces/<workspace_id>/A first example
# Push one automated result to Software Delivery Management (formerly ALM Octane).
BASE="https://octane.example.com"
SPACE=1001
WORKSPACE=1002
# 1. Sign in with API access keys; the cookie jar keeps LWSSO_COOKIE_KEY
curl -s -c cookies.txt -H "Content-Type: application/json" \
-X POST "$BASE/authentication/sign_in" \
-d "{\"client_id\": \"$OCTANE_CLIENT_ID\", \"client_secret\": \"$OCTANE_CLIENT_SECRET\"}"
# 2. The minimal payload: name, duration (ms) and status are required
cat > results.xml <<'XML'
<test_result>
<test_runs>
<test_run module="/checkout" package="com.example.checkout" class="PaymentTest"
name="paysByCard" duration="1840" status="Passed"/>
</test_runs>
</test_result>
XML
# 3. Post it; a 202 response carries a task ID to poll
curl -s -b cookies.txt -H "Content-Type: application/xml" \
-X POST "$BASE/api/shared_spaces/$SPACE/workspaces/$WORKSPACE/test-results" \
--data-binary @results.xmlWhat trips people up first
Authentication and identifiers rather than test logic. Most first attempts fail on sign-in, because a user name and password are used where API access keys are needed, which is the required method once SSO is configured, or because the request goes to the wrong shared space or workspace ID. Ask an admin for a key pair with permission on the target workspace, sign in once to get the LWSSO_COOKIE_KEY cookie, and send it with every request. Then fetch the XSD and validate your payload before posting: a payload that does not conform is rejected with a 400 and nothing is processed.
In practice
Using ALM / Quality Center in practice
Designing a stable identity for automated tests
Because Software Delivery Management identifies an automated test by component, package, class and name, those four values are the contract between your code and its test inventory. Map them deliberately: the module or service to component, the namespace to package, the test class to class and the method to name. Renaming any of them creates a new test and leaves the old one without new runs, which breaks history and coverage. If the same test runs on several browsers or environments, use environment labels or test characteristics rather than changing names, and reserve external_run_id for runs that are distinct for some other reason. Note that posting an identical payload twice returns the earlier task rather than processing it again.
<?xml version="1.0"?>
<!-- Links in the global context apply to every run in the payload -->
<test_result>
<release name="2026.10"/>
<test_fields>
<test_field type="Test_Level" value="Integration Test"/>
<test_field type="Testing_Tool_Type" value="Selenium"/>
</test_fields>
<!-- Environment labels separate runs of the same test without renaming it -->
<environment>
<taxonomy type="Browser" value="Chrome"/>
<taxonomy type="AUT Env" value="Staging"/>
</environment>
<test_runs>
<!-- Identity: module (component), package, class and name -->
<test_run module="/checkout" package="com.example.checkout" class="PaymentTest"
name="paysByCard" duration="1840" status="Passed"/>
<test_run module="/checkout" package="com.example.checkout" class="PaymentTest"
name="rejectsDeclinedCard" duration="2210" status="Failed">
<error type="java.lang.AssertionError" message="expected decline message">
java.lang.AssertionError: expected decline message
</error>
</test_run>
</test_runs>
</test_result>Pushing results from GitHub Actions
OpenText supplies a GitHub Actions integration that reports workflows, pipelines and JUnit results to Software Delivery Management, and that is the better long-term route because it links pipeline runs and commits. Where you only need results, a short REST step works with any CI and is easy to reason about: sign in with keys held as secrets, convert or generate the XML payload, post it, and check the task status so a rejected payload fails the job instead of passing silently. Run the step even when tests fail. Post in batches rather than one request per test, since processing is asynchronous and every payload becomes a task.
# .github/workflows/report-to-octane.yml
name: tests
on:
push:
branches: [main]
jobs:
test:
runs-on: ubuntu-latest
env:
BASE: https://octane.example.com
API: https://octane.example.com/api/shared_spaces/1001/workspaces/1002
steps:
- uses: actions/checkout@v7
- run: ./run-tests.sh # writes results.xml in the test_result format
- name: Report results
if: always()
env:
OCTANE_CLIENT_ID: ${{ secrets.OCTANE_CLIENT_ID }}
OCTANE_CLIENT_SECRET: ${{ secrets.OCTANE_CLIENT_SECRET }}
run: |
curl -sf -c cookies.txt -H "Content-Type: application/json" \
-X POST "$BASE/authentication/sign_in" \
-d "{\"client_id\":\"$OCTANE_CLIENT_ID\",\"client_secret\":\"$OCTANE_CLIENT_SECRET\"}"
TASK=$(curl -sf -b cookies.txt -H "Content-Type: application/xml" \
-X POST "$API/test-results" --data-binary @results.xml | jq -r '.id')
# Processing is asynchronous: poll the task until it finishes
for i in $(seq 1 30); do
STATUS=$(curl -sf -b cookies.txt "$API/test-results/$TASK" | jq -r '.status')
case "$STATUS" in
queued|running) sleep 5 ;;
success) exit 0 ;;
*) echo "Result processing ended with: $STATUS"; exit 1 ;;
esac
done
exit 1Structuring Application Quality Management projects for traceability
Traceability is only as good as the links people create. Keep the requirement tree close to how auditors and product owners talk about scope, and make test coverage of requirements part of the definition of done for test design. In Test Lab, build test sets per cycle and purpose, such as regression, smoke or release acceptance, rather than one ever-growing set, so execution reports mean something. Link defects from the failed run rather than creating them separately, which keeps the chain from requirement to defect intact. Since 26.1, site administrators can stop users adding new test coverage to requirements through a site parameter, which helps lock down validated releases.
Planning a move or an upgrade
For teams moving from Application Quality Management or Jira to Software Delivery Management, OpenText’s getting-started guide points to Shift, a migration tool on the OpenText Marketplace that migrates Application Quality Management, Silk Central and Jira projects. For synchronising with other tools, Integration Hub is now the designated solution, and the older ALM Octane Synchronizer is no longer supported, so any integration still built on Synchronizer needs replacing. On upgrades to 26.3, note the new display limit of 100,000 items in backlog, feature and defect grids and boards, and that some string filter operators were relabelled, both of which can change saved views.
Pitfalls
Common pitfalls
Searching only the new or only the old product names
Why it happens: OpenText renamed the products, but help centre addresses, community forums, marketplace listings and years of articles still say ALM, Quality Center or Octane.
The fix: Search with both names, read the help centre version that matches your server, and bookmark the latest help link the docs recommend.
Renamed automated tests losing their history
Why it happens: Software Delivery Management matches a posted run to a test by component, package, class and name. Changing any of these creates a new test entity and orphans the old one.
The fix: Treat the four identity fields as stable, map them from code structure once, and use environment labels for variations instead of new names.
One bad record failing the whole payload
Why it happens: By default, errors while processing pushed test results are not ignored and the POST fails, so one invalid reference can drop a whole build’s results.
The fix: Validate against the XSD before posting, check the task log, and use the skip-errors=true parameter only when partial ingestion is acceptable.
Password sign-in breaking after SSO is enabled
Why it happens: Scripts written with a user name and password stop working when the server moves to SSO, because the documentation says API calls should then use API key authentication only.
The fix: Use API access keys, a client ID and secret, for every non-interactive integration from the start, stored as CI secrets.
Integrations still built on Synchronizer
Why it happens: The ALM Octane Synchronizer is no longer supported, and OpenText names Integration Hub as the designated synchronisation solution.
The fix: Plan the move to Integration Hub with OpenText support, which documents a migration process from Synchronizer.
Assuming the classic client runs on every desktop
Why it happens: The Application Quality Management client downloads components that use .NET and COM, which ties it to Windows machines and complicates locked-down desktops.
The fix: Check which tasks your users can do in the browser-based Web Client, which gained several features in 26.1, and keep the classic client for the tasks that still require it.
Compared
ALM / Quality Center alternatives compared
| Tool | Where it lives | Hosting | Pricing model | Free option |
|---|---|---|---|---|
| ALM / Quality Center | Standalone OpenText platform | Off cloud or public cloud | Editions on quote, no public prices | Demos and a click tour |
| TestRail | Standalone app, integrates with Jira | Cloud, or on-premises from 10 seats | Per user: Essentials, Professional, Enterprise | 30-day trial, no free plan |
| Xray | Inside Jira, as a Marketplace app | Jira Cloud or Data Center | Licence tier must match Jira user tier | Trial through the Atlassian Marketplace |
| Zephyr | Inside Jira, from SmartBear | Jira Cloud, with an on-premises option | Essential, Standard and Advanced editions | Free trial |
FAQ
Frequently asked questions
What are the best ALM / Quality Center alternatives?
The alternatives most often weighed against ALM / Quality Center are TestRail, Xray and Zephyr. The comparison on this page sets them side by side on where it lives, hosting, pricing model and free option, and the verdict above says where ALM / Quality Center is the wrong choice and which of them to pick instead.
What is ALM Octane called now?
OpenText documents ALM Octane as OpenText Software Delivery Management; its help centre, still at the Octane address, is at version 26.3. ALM/Quality Center is sold as OpenText Application Quality Management, with a 26.1 help centre at the old ALM address. Both products are still available, and many documents, forums and integrations keep the older names.
Is ALM/Quality Center the same as ALM Octane?
No. They are separate products with separate data models. ALM/Quality Center, now Application Quality Management, is the older platform built around releases, requirements, Test Plan, Test Lab and Defects modules. ALM Octane, now Software Delivery Management, is a newer web application organised around agile backlogs, pipelines and automated test ingestion. OpenText offers migration tooling to move projects from the first to the second.
How much does OpenText ALM cost?
OpenText does not publish prices. Application Quality Management is sold in Express, Enterprise and ALM editions and Software Delivery Management in Premium and Ultimate tiers with a Developer add-on, all through sales. Ask for pricing on the deployment you need, off cloud or public cloud, and include administration and upgrade effort in any comparison with Jira-based tools.
Can I send automated test results from any framework?
Yes, for Software Delivery Management. Any CI job can post results to the test-results REST resource as XML that follows the published XSD, and OpenText supplies CI integrations, including one for GitHub Actions, that report JUnit results directly. Tests and runs are created or updated automatically, identified by component, package, class and name.
Is ALM/Quality Center still worth learning?
If you work in or with regulated enterprises such as banking, insurance, pharmaceuticals or government, yes: many still run it, often alongside UFT One, and its traceability model is what auditors expect. For a new team without that context, Jira-based tools or Software Delivery Management are more common starting points. Learning its concepts, coverage and test sets, transfers well to either.
Does Application Quality Management run on Linux?
The server does: OpenText documents that the application server can run on Windows or Linux, with Oracle or Microsoft SQL Server for the database. The classic client is different, because it downloads components that use .NET and COM, so it needs Windows. The Web Client runs in a browser, and version 26.1 added several features to it.
Alternatives
ALM / Quality Center alternatives worth weighing
Resources
Where to go next
Picking the wrong tool costs more than picking late.
QAble advises on toolchain decisions and then implements them, with engineers who have run these tools on real delivery. Start with a free QA audit.