Open Source Test Management: TestLink, Kiwi TCMS, and the Real Tradeoffs

Every open-source test management pitch stops at the price tag. Zero dollars for the license, and that part is true. What the pitch leaves out is the second invoice, the one denominated in engineering hours instead of dollars, due every month for as long as the server stays up.

That invoice covers two different jobs that never show up on a pricing page. One is infrastructure: patching a Linux box, backing up a database, and pushing through version upgrades that occasionally break a plugin you depend on. The other is authorship: writing every manual test case by hand, then rewriting it the next time the UI changes underneath it. Neither job disappears because the software itself cost nothing. That second job is where Autonoma belongs in the conversation: not as another open-source TMS, but as a way to remove the automated E2E cases that should not need to live as static records in a manual test repository.

The open-source test management options

Three projects make up the genuinely open-source end of this category. Everything else that shows up in "free test management" roundups is usually a hosted product with a generous free tier, not something you can clone and self-host.

TestLink is the name most people mean when they say "open source test management." It has been around longer than almost anything else on this list, runs on a standard PHP and MySQL stack, and stores test plans, cases, and execution results in a model that hasn't changed much over the years. Kiwi TCMS is the newer entrant, built on Python and Django, released under GPLv2, and maintained with a visibly more active release cadence, including official reporters for pulling results straight out of Playwright, Cypress, and pytest runs. Squash TM is built by Henix and released under LGPL, and it adds something neither of the other two focuses on: linking test cases back to requirements, which matters more to teams working under a formal traceability mandate than to a typical product team.

Plenty of other names surface in "free and open source test management" searches, and most of them don't hold up under a second look. Some are hosted products offering a generous free tier gated by seat count or test-run volume, which is a legitimate business model but not open source in any license sense. Others were open source once and have since gone quiet enough that treating them as an active option today would be dishonest. Sticking to three verifiably open and maintained projects here is a deliberate choice, not an oversight.

If you want the fuller landscape, including paid standalone and Jira-native tools, best test management software covers the buyer-neutral shortlist by use-case, and test case management tools is the broader hub comparing every major option feature by feature. If your team is closer to "we just want something free to try before committing," free test case management covers the hosted free-tier side of that question rather than the self-hosted side this post focuses on.

TestLink vs Kiwi TCMS: the two leaders compared

TestLink has the longer track record. Kiwi TCMS has the newer engine underneath it.

The two leaders split cleanly on stack, database, and CI integration depth.

That difference in age shows up everywhere you look. TestLink's interface reflects the web application conventions of the era it was built in: dense pages, full-page reloads, and a layout that prioritizes information density over visual polish. It works, and thousands of teams have run real suites through it for years, but nobody would call the experience modern. Kiwi TCMS looks and behaves like software built in the last few years, because it was, and that shows in smaller details like inline editing and a UI that doesn't require a page reload for every action.

Integrations follow the same split. TestLink has a Jira connector and can export and import in a handful of formats, but connecting it to a CI pipeline is glue work you write yourself. Kiwi TCMS ships official reporter plugins for Playwright, Cypress, and pytest, plus two-way Jira sync, which means less custom scripting to get automated results flowing into either tool. Maintenance activity tells a similar story: Kiwi TCMS's public repository shows a steady cadence of releases and fixes, while TestLink's development pace has slowed relative to its earlier years, which is common for a project of its age but worth knowing before you commit a team's workflow to it.

Database support is one place the age gap becomes concrete. TestLink runs on MySQL, reflecting the LAMP-stack conventions common when it was first built. Kiwi TCMS runs on PostgreSQL by default, in line with how most Python and Django projects get deployed today. Neither choice is wrong, but the operational skills your team needs to keep either database healthy differ depending on which one you pick, and that's worth checking against what your infrastructure team already knows how to run before you commit.

Neither difference makes one project objectively better. A team that mostly needs a durable, no-frills case repository and doesn't lean on CI integrations can run TestLink for years without hitting its limits. A team already automating heavily and wanting test results to land automatically without custom scripting will get there faster with Kiwi TCMS.

The real cost of open-source test management

None of that license-fee line item captures what actually consumes time once either tool is running in production. Autonoma does not make self-hosting cheaper for manual test management; it changes the automated E2E slice so fewer brittle cases need to be written, stored, and rewritten there in the first place.

The license invoice reads $0. The second one, paid in engineering hours, arrives every month.

Someone has to provision the server, whether that's a VM, a container, or a managed database sitting behind it. That same person, or whoever inherits the job when they leave, keeps the OS patched, rotates backups, and monitors the thing for downtime, because a self-hosted test management tool that's actually down during a release crunch has effectively removed test management from the release. Version upgrades are their own project: a major TestLink or Kiwi TCMS upgrade can require a database migration, and any custom plugin or Jira connector you've wired in is exactly the kind of integration that tends to break first when the underlying framework moves versions. None of this is exotic sysadmin work, but it is real, recurring, and rarely budgeted as part of "we chose the free option."

There's a second layer of integration maintenance beyond the CI reporters mentioned above. Most teams put either tool behind a reverse proxy with its own SSL certificate to renew, and larger organizations often want LDAP or SSO tied into login, which is configuration work the open-source project itself won't do for you. Backups are only real backups if someone has actually tested restoring from one; a backup nobody has restored is a hypothesis, not a safety net. None of this is unusual for self-hosted software in general, but it's the exact category of work a paid, hosted TMS quietly absorbs into its subscription price.

Support is the other line item the license fee doesn't cover. When a commercial TMS breaks during a release, there's a support ticket and, usually, an SLA. When a self-hosted open-source TMS breaks, there's a GitHub issue, a community forum post, or a maintainer's inbox, and a fix arrives on their schedule, not yours.

None of this means open-source test management is a bad choice. For a budget-constrained team that wants to own its test data outright and already has the operational capacity to run internal services, TestLink or Kiwi TCMS is a legitimate, defensible pick. The honest framing is simply that the invoice moved from a line item on a vendor contract to hours on your own team's calendar, and that second invoice is worth costing out before you commit.

When open-source test management stalls (and the alternative)

Three stall points show up often enough to name directly. The interface age gap is real: TestLink's screens haven't meaningfully modernized in years, and even Kiwi TCMS's improvements are incremental rather than a ground-up redesign. Integration depth is real but narrow: Kiwi TCMS's official reporters cover Playwright, Cypress, and pytest well, but a team standardized on a different framework is back to writing its own glue code. And support is community-only in both cases, fine until a release is blocked on a bug that only a maintainer can triage, on their own schedule.

Even with the infrastructure bill paid, one cost never goes away: someone still has to write every manual test case by hand, and someone still has to rewrite it the moment the UI it describes changes.

That's where open-source test management stalls hardest for teams with a heavy automated E2E slice. A test case sitting in TestLink or Kiwi TCMS is a static record: a set of written steps a human authored at a point in time. When a button moves, a flow changes, or a new field gets added, that written record doesn't update itself. Someone has to notice the drift, open the case, and rewrite the steps, sprint after sprint, on top of whatever server and upgrade maintenance they're already doing. The license was free. The authoring and re-authoring never was.

A static case waits for a human to notice the drift; a self-maintaining one updates from the code itself.

This is a narrower gap than "open-source test management is bad," and it's worth being precise about the boundary. Both TestLink and Kiwi TCMS remain the right tool for storing and reporting on manual, exploratory, and compliance-driven test cases, work that genuinely benefits from a human-maintained repository. What they were never built to do is keep an automated end-to-end suite in sync with a codebase that changes every day. Autonoma exists specifically for that slice: instead of a human writing a test case and coming back to edit it every time the UI shifts, a Planner agent reads the codebase directly and plans test cases from the actual routes and components, an Executor agent runs them against a live preview environment, and a Diffs Agent watches every pull request's code changes and updates, adds, or deprecates cases to match, the same maintenance work a person would otherwise redo by hand.

Put differently, Autonoma isn't competing with TestLink or Kiwi TCMS as a place to store manual test cases. It's an answer to a different question: how much of that inventory should exist as a static, human-maintained record at all, versus a self-maintaining process that regenerates itself from the code every time the code moves. If your suite is mostly manual and exploratory, an open-source TMS is still the right home for it. If most of what's rotting in that TMS is automated browser and E2E coverage, that's the slice worth pulling out first.

This post is deliberately scoped to test-case management, not automation frameworks or AI-native test generation, which are different questions with different answers. For the open-source frameworks and platforms you'd use to actually build and run automated tests, best open-source test automation tools in 2026 covers that landscape, and for tools that use AI to generate test code from natural language or requirements, open-source AI test generation tools covers that narrower category directly.

FAQ