Public beta · release/v1.1Next up after 1.0

What's next in TestPlanIt 1.1

Every release raises the same three questions: is it covered, what do we retest, and can we prove it? TestPlanIt 1.1 is built to answer them. Requirements management ties every test case to what it verifies — authored natively or mirrored from Jira, Azure DevOps, GitLab, GitHub, Gitea, Redmine or MantisBT — with coverage rollups, suspect flags and traceability snapshots on top. Impact Analysis reads the git diff of the application under test and shortlists the tests that change touches. And Automated Execution runs that shortlist in your CI, straight from the test run.

504
Commits
~3,000
New tests
7
Trackers synced
5
Git providers

Headline features

Requirements, natively in TestPlanIt

Requirements · New

Every project gets an opt-in Requirements area: a tree of what the system should do, nested to any depth, with multiple independent hierarchies side by side. Author requirements directly — rich-text documentation, attachments, priority and status — or designate which tracker issue types count as requirements and TestPlanIt mirrors them, hierarchy included, as live synced requirements. Jira, Azure DevOps, GitLab, Redmine and MantisBT classify by issue type; GitHub and Gitea classify by label, and any single issue can be promoted or excluded by hand.

Each requirement carries a provenance badge — Manual, Synced or Detached — so you always know who owns it. Synced requirements keep the tracker’s title, status, priority and parent locked while your documentation, attachments and links stay editable; detach one and it becomes fully yours, badge intact. Every change to a requirement’s text is versioned with per-field diffs. Reorganize by drag and drop, open any requirement on its own addressable page, link test cases from either side — including cases in other projects — and see a case’s linked requirements while you execute it.

Coverage you can see — and defend

Traceability · New

Every requirement rolls up the latest result of every case covering it, through its whole subtree — Passed, Failed, Not run or Uncovered — with per-status counts and a drill-down that links each result back to the run it came from. Scope the rollup to a milestone or configuration to ask “is this covered on this release?” When a requirement’s content changes after a linked case last ran, the link is flagged Suspect: re-executing the case clears it automatically, or dismiss it after review.

Three pre-built reports put it in front of stakeholders. Requirement Traceability pairs every requirement with its cases and their latest results; Requirement Coverage Gaps ranks your coverage debt — and generates test cases straight from a gap row; Requirement Coverage Changes compares two points in time. Because the live matrix moves with every execution, a Snapshot freezes it — every requirement, its covering cases and their results, stamped with who captured it and why — so release sign-off has evidence, not a screenshot.

Test what changed, not everything

Impact Analysis · New

Point TestPlanIt at the repository of the application under test — GitHub, GitLab, Bitbucket, Azure DevOps or Gitea — pick two commits or a pull request, and get the Affected Tests right where you compose the run. It works from the git diff alone: no coverage agent, no build step, no instrumentation. A project whose application spans several services can connect a repository per service.

Every selection explains itself. Code Pins tie a test case to a file, line range, symbol or glob — added on the case page or declared in the repository with an @testplanit annotation or a map file. A commit that names a ticket pulls in every case linked to it. Keyword matching, prior runs that covered the same change and an AI ranking against the diff fill in the rest, each with its own reason badge. Or let the repository start the analysis: a pull request opened or a push to your base branch runs it and composes a test run of the affected cases, named after the event.

Execute automation from the test run

Automated Execution · New

A test run used to be where automated results ended up; now it is also where they start. Compose the run — from the Affected Tests, or however you like — click Execute automated cases, and the automated portion runs in your CI while testers pick up the manual cases. A single automated case gets Execute automated test for the same thing in miniature. Manual and automated results share one checklist with one status per case, and the newest result wins.

TestPlanIt starts the job on an execution target the project configured — a GitHub Actions workflow, a GitLab CI pipeline, or a signed webhook for Jenkins and anything else — and hands it the run id plus a URL where the job fetches its plan of cases. There is no agent to install and nothing framework-specific inside TestPlanIt: the plan lists each case with the identifiers a runner filter can match on, your job turns them into a grep or filter expression, and the reporter or CLI you already use reports back into that run.

One instance, every directory

SCIM · New

Organizations rarely have one identity provider. 1.1 lets Okta manage your employees and Entra manage your contractors on the same TestPlanIt instance: each user and group records which IdP provisioned it, each IdP sees only its own directory, and a write across that line is refused and logged rather than silently overwriting.

Rotate a SCIM token in place with an overlap window — from an immediate cut-over to 30 days — so provisioning never breaks between re-keying and pasting the new value into your IdP. Map IdP-asserted roles to access tiers, taking precedence over group mappings so contractors stay at User even inside an Admin-mapped group, and scope a group to the projects it works on instead of the whole instance.

Requirements, in detail

Classify by issue type — or label

Pick the issue types that count as requirements (Epic, Story, a custom type) per integration; GitHub and Gitea select repository labels instead. An impact preview shows what will change before you save, and removing a type is reversible.

Promote, exclude, resetNew

Override the rule for a single issue: promote a bug into the requirements tree, exclude a story that shouldn’t be there, and reset either back to what its type says.

Hierarchy mirrored from the tracker

Synced epics, stories and sub-tasks keep their parent/child structure, completed within a single import run. Tracker priority is mirrored too — no more fabricated “medium”.

Detach to take ownership

Release a synced requirement to local editing in one click. It keeps its tracker badge and link, and becomes as editable as a manual one.

Content historyNew

Every change to a requirement’s title, description or documentation — edited here or arriving from a sync — is a numbered content version with per-field diffs, and snapshots record which version each requirement was at.

Rich documentation on every requirement

Rich-text notes and file attachments, staged with the rest of your edits and saved or discarded together — on synced requirements too.

Coverage scoped to a release or environmentNew

Milestone and configuration pickers narrow the rollup to executions from matching runs — a release scope includes its sprints — in the list, the detail panel and both coverage reports.

Requirements while you testNew

The execution sheet shows the requirements a case covers, and a Linked Requirements panel on Test Case Details lets you link more from the case’s own project.

Built for thousands of requirements

Above a threshold the tree loads a window at a time — roots first, children on expand, more rows as you scroll — with search and the Coverage, Status and Source filters resolved on the server and every match returned with its ancestor chain.

Drag-and-drop reorganizing

Grab handles, outlined drop zones and a root-level strip; invalid moves such as dropping a requirement into its own subtree are rejected server-side.

Delete a subtree, recover from Trash

Deleting cascades through descendants and says exactly how many; it’s a soft delete, restorable from the Trash.

Defect lists stay defect lists

Requirement rows are kept out of issue lists, issue pickers, issue-tracking reports and the MCP issues tool by default — their coverage is reported by the requirement reports instead.

Impact Analysis, in detail

Code PinsNew

Pin a test case to a file, a line range, a function or class, or a glob pattern from the Code Pins panel on the case page. Any change inside a pinned block selects the case first; a pin whose lines no longer exist still matches at file level and is flagged Stale.

Pins declared in the repositoryNew

Put @testplanit case:123 in a comment above the code it covers, or list globs against case ids and tags in .testplanit/testmap.yml. Markers are scanned on every cache refresh and problems are reported on the settings page.

Tickets in commit messagesNew

A commit naming PROJ-123, #42 or AB#42 selects every case linked to that ticket and leaves a Ticket pin on the functions it changed. Tickets TestPlanIt doesn’t hold yet are imported from the tracker, ready to link.

Rescan or walk the full historyNew

Rescan Recent Commits and Scan Full History run on demand, report progress by stage, can be cancelled, and resume where a capped scan stopped — so pins backfill for tickets linked later.

Pull request modeNew

Choose a pull request instead of two commits — filtered by Open, Merged or Closed — and it’s measured from the merge base, so the diff describes what the PR did and nothing that landed on the target branch meanwhile.

Several repositories per projectNew

One connection per service, each with its own branch, path patterns, cache and pins. The Impact dialog, the Code Pins panel and the settings page gain a repository choice, and the repository page gets a Code Pins column and filter.

Repository webhooksNew

An opened pull request is analyzed against its target branch; a push to the base branch analyzes the pushed commits; optionally, a push to any branch is compared against base. Each analysis composes a run of the affected cases. GitHub, GitLab, Bitbucket, Azure DevOps and Gitea.

Every reason on the recordNew

Each affected test carries a score and a Pinned, Affected or Related tier, with Pin, Ticket, Keyword, History and AI badges explaining why — including the AI’s rationale — so the team can trust the shortlist and add to it.

Start where you left offNew

Start from a previous analysis to set the base to its head commit, paste any ref, or jump to the latest on a branch. The same two commits within 24 hours reuse the completed analysis.

Automated Execution, in detail

Execution targetsNew

Project Settings → Automated Execution holds GitHub Actions workflow, GitLab CI pipeline and signed-webhook targets — Jenkins, Buildkite, CircleCI or a home-grown runner — with static inputs, a timeout and a Verify check that catches a bad credential or missing workflow input before you dispatch.

A plan, not a list of idsNew

The job fetches GET /api/test-runs/{id}/automation-plan (or runs testplanit run plan) and gets every automated case with the id tokens, class and full name a runner filter can match on — so a run of any size fits, and nothing framework-specific lives in TestPlanIt.

Hybrid runsNew

A manual run becomes hybrid the first time automated results land in it. Each result updates its case, the progress bar and ready-to-complete check reflect both kinds of execution, and any case can still be executed by hand.

Execute a single caseNew

Execute automated test on a case page or the repository row menu creates a run holding just that case, which completes itself once the job finishes and its results are in.

Track, cancel, retryNew

An execution chip on the run shows Pending, Dispatched, Running, Succeeded, Failed, Could not start, Timed out or Cancelled, with a link to the job. Cancel asks the provider to stop; Retry reopens the dialog; Execution history survives run completion.

Reporters that attach to a runNew

The Playwright and WebdriverIO reporters and the CLI treat a run named by TESTPLANIT_RUN_ID as externally managed: they attach results and never create or complete a run of their own. Two outbound webhook events and audit entries follow the lifecycle.

Integrations & sync

One Import Issues action

A single dialog per linked project covers both a recent, capped sample and an uncapped All-history run of your requirement types — it tells you how many the tracker holds before writing anything, runs in the background, and can be stopped keeping everything imported so far.

Attach issues by keyNew

A ticket key like PROJ-123 is all it takes to link an issue from a CSV import, the API or an AI agent on the MCP server — nobody has to open the ticket in TestPlanIt first, so a repository with thousands of ticket references migrates in one import.

Issue-type scoped searches

Jira, Azure DevOps, Redmine and GitLab queries scope themselves to specific issue types, with GitLab paging each type independently; Azure DevOps and MantisBT imports page correctly past the first window.

Tracker creation dates preserved

Each synced issue keeps its own created date from the tracker, which powers the gap report’s Uncovered Since column.

Requirement Sync settings

A new section on the active integration’s settings for the seven requirement-capable trackers; issue integration settings are merged into one card and Milestone Sync moves to an explicit Save.

Inbound webhooks, one wizardNew

A single Add inbound webhook flow covers issue-tracker and repository sources, both kinds list together with health, deliveries and Send test, and Bitbucket joins the inbound providers.

Reports & tables

Requirement Traceability report

One row per requirement–case pair with parent path, coverage state, latest result and project, plus a donut of coverage states and a per-hierarchy coverage breakdown.

Requirement Coverage Gaps report

Zero-linked and never-run tiers, an On Closed Requirements count, debt by top-level requirement, and debt aging from under 30 days to over a year.

Requirement Coverage Changes reportNew

Pick a baseline snapshot and compare it to the live matrix or a later snapshot to see exactly which requirements’ coverage moved, and how.

Generate tests from a gapNew

Every gap row ends with a Generate Test Cases button that opens the AI wizard pre-seeded with that requirement — its title, body and, for synced requirements, the tracker description.

Cross-project requirement reportsNew

Administrators run the traceability and gaps reports across every project with requirements enabled at once, from Reporting & Analytics, with a Requirement Project filter in one shared menu.

Scope, filter, share

Scope either report to selected subtrees, filter traceability by coverage state, and share links carry the scope — and every pre-built report’s parameters now survive the share redirect.

Editing, AI & platform

Auto-save and draft recoveryNew

Test case edits are kept in the browser as you type and on the server a few seconds after you stop, in the Add Case dialog and in edit mode. Reopen the case and choose Restore or Discard; nothing reaches the case until you click Save.

DeepSeek, first classNew

DeepSeek V4 Flash, V4 Pro and the Flash Vision preview get their own integration with model selection, thinking mode and cost defaults — one step instead of the generic OpenAI-compatible workaround.

Retry one generated caseNew

When AI test generation returns a case that failed review, retry just that one from the review step instead of regenerating the batch.

Beta channel imagesNew

Every push to release/v1.1 cuts the next 1.1.0-beta automatically: a GitHub pre-release, self-host server and worker images on the 1.1-beta channel tag, and the Helm chart at that version.

Upload limit on prebuilt imagesNew

UPLOAD_MAX_MB now takes effect on the official images as well as source builds, so raising the attachment ceiling is a variable change rather than a rebuild.

In-app upgrade notesNew

After upgrading, admins and users get a What’s New notice for 1.1 inside the app, linking to the release announcement and the settings pages where each feature is switched on.

Compiled from the public release/v1.1 branch at 1.1.0-beta.3, plus the impact-analysis work landing on it this week — 504 commits since the branch left the 1.0 line · Aug 18 – Sep 14, 2026 · 194 feature commits, 277 new test files. Everything listed is implemented and verified on the branch; names, details and the release date may still change before 1.1 ships. Requirements linkage began life as GitHub issue #501 — thank you to everyone who weighed in.

Want 1.1 before it ships?

Every push to release/v1.1 cuts a new 1.1.0-beta — a GitHub pre-release, self-host images on the 1.1-beta channel tag, and a matching Helm chart. Pull the beta image, or build the branch from source, and everything on this page is yours today. It’s pre-release software — back up your database first.

Just released: see everything in TestPlanIt 1.0