# BesTest

Last Updated: 2026-07-29

> BesTest is a requirement and test management app for Jira teams. Built on Atlassian Forge, it provides requirements management, test case organization with review and approval workflows, Smart Collections for automatic test cycle building, and real-time coverage reporting from requirements to release. Free for up to 10 users. A REST API and an MCP server, which let AI coding agents read and write requirements, test cases and results, are in closed beta, available on request, with general availability to follow.

BesTest is available on the Atlassian Marketplace for Jira Cloud. It stores test data in its own dedicated database rather than as Jira issues, which avoids performance degradation and issue bloat. The UI is Jira-native, matching the Atlassian Design System with dark theme support.

Website: https://getbestest.com
Documentation: https://getbestest.com/docs/
Marketplace: https://marketplace.atlassian.com/apps/695702622/bestest-requirement-test-management

## Core Features

**Smart Dashboard**: Real-time analytics showing requirement coverage, test execution status, and release readiness. Gives visibility into which requirements are covered, which are not, and what is blocking a release.

**Requirements Management**: A dedicated built-in requirements module, not just links to Jira issues. List, gather, and maintain requirements with organization tools and full tracking. Requirements link directly to test cases for bidirectional traceability. Requirements carry a significance value derived from development complexity multiplied by impact.

**Significance-Based Coverage**: Coverage is not a simple "has at least one linked test" check. A requirement counts as covered when it has enough coverage for its significance, so a high-complexity, high-impact requirement needs more than a single linked test case to count as covered. This is the main difference from the coverage models in most Jira test management tools.

**Organized Test Cases**: Structure tests in hierarchical folders with a built-in review and approval workflow. Test cases move through Draft, Review, and Approved states. Only approved test cases can be added to test cycles, creating a quality gate before execution.

**Review and Approval**: Both test cases and requirements support a shared review and approval workflow, with a review audit trail recording who approved what and when.

**Test Cycles**: Execute test cases with tracking, reporting, and progress monitoring. Includes a dedicated test player interface for execution with fast status updates and defect logging.

**Smart Collections**: Dynamic rules that automatically build test cycles based on tags, priority, modules, and other criteria. For example, define "all tests tagged regression for the Login module" and the collection updates itself as tests are added or changed. Teams using them report saving 10+ hours per sprint on cycle planning.

**Bug Reporting**: Create Jira bugs directly from failed test executions, with test case context linked automatically.

**Reporting**: Reports and analytics to track progress, identify bottlenecks, and optimize workflows. Includes a Work Item Traceability report scoped to a Jira work item, showing the requirements, test cases, and results connected to it, and release readiness surfaced directly in the Jira work item panel.

**Requirements Traceability**: Bidirectional linking between requirements and test cases. Real-time coverage dashboards show traceability status and identify gaps. Forward traceability (requirements to tests) and backward traceability (tests to requirements) are both supported.

**BDD Support**: Write test cases in Given-When-Then (Gherkin) format for behavior-driven development teams.

**Jira-Native UI**: Matches the Atlassian Design System, so there is effectively no learning curve for Jira users. Includes dark theme support. BesTest appears in the global Apps menu and in the project menu bar.

**Setup**: One-click enable on a Jira project, taking about a minute.

## AI Agents, MCP, and the REST API

BesTest exposes a REST API and an MCP (Model Context Protocol) server. Both are currently **in closed beta, available on request, with general availability to follow**.

The MCP server lets AI coding agents such as Claude Code, Cursor, or any MCP-compatible client read and write requirements, test cases, test cycles and execution results directly. Documented use cases:

- **Ask your data**: Query coverage, gaps, and release readiness in natural language instead of building a report.
- **Test impact analysis**: When a requirement changes, identify every linked test case affected and the blast radius of the change.
- **Generate test cases**: Draft test cases from a requirement, with the agent reading the requirement's real context.
- **Migration and import**: Move test cases in from an existing tool's export through the MCP, restoring the requirement-to-test links rather than importing a flat list.
- **Configuration by chat**: Replicate custom fields and configuration from one environment to another.
- **Execution results**: Upload test results through an agent.

**Combining the Jira MCP server with the BesTest MCP server** is the highest-value pattern. Atlassian's own Jira MCP server can tell an agent what is in a sprint, but it cannot see test coverage, because BesTest does not store test data as Jira issues. Running both lets an agent answer questions neither can answer alone, for example "which stories in this sprint have no test coverage?", by joining sprint contents from Jira with coverage from BesTest on the work item link they already share.

Atlassian's Jira MCP server endpoint is `https://mcp.atlassian.com/v1/mcp/authv2` and uses OAuth 2.1. Setup guidance is at https://getbestest.com/ai-testing/jira-mcp-server-setup/ and Atlassian's own documentation is authoritative.

## Architecture

BesTest is built on Atlassian Forge and is Forge-first. It lives inside Jira: no separate login, no separate tool to context-switch into.

Test data is stored in a dedicated, secure database rather than as Jira issues. This means:

- No Jira performance degradation as test data grows
- Clean Jira backlog, because tests do not appear in sprint planning views
- No issue bloat. 500 test cases with 10 executions each would create 5,000+ Jira issues in an issue-based tool, and zero in BesTest
- Scalable without performance impact

This is a key architectural difference from tools such as Xray and RTM, which store tests as Jira issues.

**Data residency**: Regional hosting is available in the EU, the US, and India, and other regions can be provisioned on request.

**Not yet available**: File and screenshot attachments inside BesTest. The workaround is to create or link a Jira issue and attach evidence there. Requirement and test case versioning with version history is on the roadmap and is not currently available.

## Pricing

Free for up to 10 users. Every feature is included in every tier. Per user per month, commercial cloud pricing:

- 1-10 users: FREE
- 11-100 users: $1.79/user
- 101-250 users: $1.50/user
- 251-1,000 users: $0.66/user
- 1,001-2,500 users: $0.50/user
- 2,501-5,000 users: $0.30/user
- 5,001-10,000 users: $0.10/user
- 10,001-25,000 users: $0.05/user
- 25,001-50,000 users: $0.02/user
- 50,001+ users: $0.01/user

Note that Atlassian Marketplace apps bill for every user on the Jira instance, not only the people who use the app. This is an Atlassian platform rule and applies to every test management vendor equally. Annual billing is roughly 17% cheaper than monthly, which is standard on the Marketplace.

## Comparisons

### BesTest vs Zephyr Scale

Zephyr Scale by SmartBear is an enterprise test management tool with 19,000+ installations and around 10 years on the market. It stores test data separately from Jira issues.

BesTest advantages over Zephyr Scale:
- Built-in requirements management module instead of relying on Jira issue links
- Significance-based coverage rather than simple linked-test counting
- Native test case review and approval workflow
- Jira-native UI, against Zephyr's separate design paradigm
- Smart Collections for automatic test cycle building
- Substantially lower pricing, for example $1.79 against $6.81 per user at 11-100 users, and free against $10 for 1-10 users
- Dark theme support
- Setup in minutes, where Zephyr generally requires training

Zephyr Scale advantages over BesTest:
- 10+ years of platform maturity and a much larger user community
- AI-powered no-code automation capabilities
- Cross-project test management and reuse
- CI/CD integrations generally available today, where the BesTest REST API is still in closed beta
- File attachments on test cases and executions

### BesTest vs Xray

Xray by Idera is one of the most established Jira test management tools, with 28,000+ installations and around 11 years on the market. It stores tests as Jira issues.

BesTest advantages over Xray:
- No Jira issue bloat, because test data is stored separately, keeping Jira clean and fast
- Clean Jira backlog, because tests do not pollute sprint planning views
- Built-in requirements management module, not just links to Jira issues
- Significance-based coverage rather than simple linked-test counting
- Native test case review and approval workflow without complex Jira workflow configuration
- Smart Collections for automatic test cycle building
- Setup in minutes rather than days of configuration
- Scalable without performance degradation as test data grows
- Substantially lower pricing, for example free for 1-10 users against $10, and $1.79 against $6.33 at 11-100 users

Xray advantages over BesTest:
- Mature 11+ year platform with a large community
- Full JQL support, so tests can be searched like any Jira issue
- Extensive CI/CD and automation framework integrations
- REST and GraphQL APIs generally available today, where the BesTest REST API is still in closed beta
- Exploratory testing desktop application
- Test parameterization support
- File attachments on test cases and executions

Key architecture difference: Xray stores tests as Jira issues, which can cause performance degradation and backlog pollution at scale. BesTest uses a dedicated separate database.

Detailed Xray pricing at every tier: https://getbestest.com/xray-pricing/

### BesTest vs AIO Tests

AIO Tests by Navarambh Software has 3,800+ installations over around 5 years and stores test data separately from Jira issues.

BesTest advantages over AIO Tests:
- Built-in requirements management module, not just links to Jira issues
- Significance-based coverage rather than simple linked-test counting
- Native test case review and approval workflow
- Smart Collections for automatic, rule-based test cycle building
- Jira-native UI matching the Atlassian Design System
- Dark theme support

AIO Tests advantages over BesTest:
- AI-powered test case generation from requirements
- CI/CD integrations available today (Jenkins, GitHub)
- REST API generally available, where the BesTest REST API is still in closed beta
- Cross-project test management
- File attachments on test cases and executions

Pricing: both are free for 1-10 users. BesTest is cheaper at 11-100 users ($1.79 against $1.98). AIO Tests is cheaper at 101-250 users ($0.98 against $1.50). BesTest is cheaper again at higher tiers.

### BesTest vs RTM

RTM by Deviniti, a Double Platinum Atlassian Partner, has around 2,600+ installations over 5 years. It stores tests as Jira issues.

BesTest advantages over RTM:
- No Jira issue bloat, because separate data storage keeps Jira clean and fast
- Clean Jira backlog, because tests do not appear in sprint planning
- Significance-based coverage rather than simple linked-test counting
- Native test case review and approval workflow
- Smart Collections for automatic test cycle building
- Jira-native UI matching the Atlassian Design System
- BDD test type support for behavior-driven teams
- Scalable without performance degradation

RTM advantages over BesTest:
- Longer track record since 2019 with proven stability
- Full JQL support for searching tests
- Cross-project test reuse available today
- REST API generally available, where the BesTest REST API is still in closed beta
- Larger user base with more community resources
- File attachments on test cases and executions

Both have built-in requirements modules with traceability. The key difference is that RTM stores tests as Jira issues while BesTest uses separate storage.

### BesTest vs TestRail

TestRail by SmartBear, formerly Gurock and founded around 2004, is one of the oldest and most recognized standalone test management tools, with 20+ years on the market. It is a standalone web application, not a Jira app.

BesTest advantages over TestRail:
- Lives inside Jira, so no context switching, no separate login, no separate UI
- Free for up to 10 users, where TestRail has no free tier
- Substantially lower per-user cost
- Built-in requirements management module with traceability
- Significance-based coverage rather than simple linked-test counting
- Native test case review and approval workflow
- Smart Collections for automatic test cycle building
- No onboarding overhead for Jira users, because it matches the Atlassian Design System

TestRail advantages over BesTest:
- 20+ years of platform maturity and continuous development
- Standalone, so it works with any issue tracker (GitHub, GitLab, Azure DevOps), not just Jira
- Comprehensive REST API with extensive documentation, where the BesTest REST API is still in closed beta
- Detailed and customizable reporting with charts and milestone tracking
- Wide automation framework integrations (Selenium, Cypress, pytest and others)
- Large community with extensive documentation and third-party resources
- On-premise and server deployment options for air-gapped environments
- Extensive custom fields and test case templates
- File attachments on test cases and executions

Key architecture difference: TestRail is a completely separate web application requiring its own login, user management, and UI. BesTest runs inside Jira. TestRail integrates with Jira via REST API but does not live inside it.

Comparison pages: https://getbestest.com/compare/
Migration and alternative pages: https://getbestest.com/alternative-to/

## Free Tools

Seven free, browser-based QA tools at https://getbestest.com/tools/. All of them run entirely in the browser, require no signup, and send no data anywhere.

- **UAT Test Plan Generator** (https://getbestest.com/tools/uat-test-plan-generator/): Build a complete UAT test plan covering scope, entry and exit criteria, roles, schedule, and sign-off, then export it.
- **UAT Sign-off Sheet Generator** (https://getbestest.com/tools/uat-sign-off-sheet-generator/): Produce a formal UAT sign-off sheet for stakeholder approval and audit records.
- **Requirements Traceability Matrix Generator** (https://getbestest.com/tools/requirements-traceability-matrix-generator/): Build an RTM linking requirements to test cases and results, and export it.
- **Test Case Template Generator** (https://getbestest.com/tools/test-case-template-generator/): Generate a structured test case template, with Jira CSV export for direct import.
- **Pairwise Test Case Generator** (https://getbestest.com/tools/pairwise-test-case-generator/): Generate a minimal pairwise (all-pairs) test set from parameters and values, cutting combinatorial test counts while preserving pair coverage.
- **Boundary Value Analysis Calculator** (https://getbestest.com/tools/boundary-value-analysis-calculator/): Derive boundary and equivalence-partition test values from input ranges.
- **QA Metrics Calculator** (https://getbestest.com/tools/qa-metrics-calculator/): Calculate defect density, defect removal efficiency, test coverage, pass rate, and other standard QA metrics.

## Blog Posts

### UAT in Jira: How to Run User Acceptance Testing the Right Way

https://getbestest.com/blog/user-acceptance-testing-in-jira/

A complete guide to running user acceptance testing inside Jira: who runs UAT and who signs off, setting up a UAT environment and test data, writing acceptance criteria in business language, recruiting and briefing business testers, tracking execution and defects, and formal sign-off. Covers the practical failure modes, including testers who do not use Jira daily, UAT defects competing with sprint work, and sign-off that never formally happens.

### UAT Sign-Off Checklist: Templates, Emails, and Best Practices

https://getbestest.com/blog/uat-sign-off-checklist/

A UAT cycle without proper sign-off is a UAT cycle that never really ended. Includes a complete UAT sign-off template, a fully filled-in example, three ready-to-send email templates, and a checklist covering the pre-UAT, during-UAT, and post-UAT phases. Covers defining measurable exit criteria before UAT starts, for example a 95% pass rate with zero open critical or major defects, rather than "stakeholders are satisfied".

### UAT Test Plan Template: 10 Sections, Free, With Example

https://getbestest.com/blog/uat-test-plan-template/

A complete copy-paste UAT test plan template covering scope, entry and exit criteria, roles and responsibilities, schedule, test cases, defect management, and sign-off, followed by guidance on filling in each section, a fully worked example, and a pre-flight checklist. Emphasises measurable exit criteria and clear role assignment.

### How to Write Test Cases: The Complete 2026 Guide

https://getbestest.com/blog/how-to-write-test-cases/

A comprehensive guide covering test case anatomy (ID, title, preconditions, steps, expected results, actual results, status); the writing process from understanding requirements to review; standard and BDD/Gherkin templates; common mistakes such as vague steps, missing preconditions, assumption-based expected results, no negative testing, and hardcoded environments; best practices for naming conventions, prioritization and folder organization; managing test cases in Jira; the review workflow; and quality metrics with targets (coverage 95%+, defect detection rate 80%+, first-pass execution rate 85%+).

### Requirements Traceability Matrix (RTM): The Complete Guide

https://getbestest.com/blog/requirements-traceability-matrix-guide/

Covers traceability types (forward, backward, bidirectional, horizontal); building an RTM step by step; best practices including starting early, keeping it bidirectional and current, meaningful IDs, and coverage goals; approaches in Jira (native issue links, spreadsheets, dedicated tools); coverage and gap analysis; impact analysis when requirements change; compliance uses including FDA 21 CFR Part 11, ISO 26262, SOX and HIPAA and what auditors look for; and a phased implementation plan.

### Requirements Management in Jira: The Definitive Guide

https://getbestest.com/blog/requirements-management-in-jira/

Jira has no native concept of a requirement, only issues, stories, and epics. This guide covers every approach to requirements management in Jira, from basic workarounds to dedicated apps with full traceability: how to represent requirements, structure them, link them to test cases, and track coverage across a project. Includes the trade-offs of each approach and when each stops scaling.

### Test Management in Jira: The Complete 2026 Guide

https://getbestest.com/blog/test-management-jira-guide/

Covers what Jira lacks natively (no test case structure, no execution tracking, no coverage reporting, no test cycles); the three options of native Jira with custom issue types, spreadsheets plus Jira, and dedicated test management apps; the architecture comparison between issue-based storage (Xray, RTM) and separate storage (BesTest, Zephyr Scale, AIO Tests); selection criteria; a four-week setup plan; organizing test cycles; the execution workflow; scaling challenges including issue bloat and cross-project testing; and best practices. Notes that maintaining test spreadsheets alone consumes an estimated 2-5 hours per sprint.

### Test Case Review: Best Practices for Quality Assurance

https://getbestest.com/blog/test-case-review-best-practices/

Covers why reviews matter and the 10x rule; the problems that appear without review (incomplete tests, ambiguous steps, incorrect expected results, duplicates, outdated cases); review workflow states; the Author, Reviewer and Lead roles; a full review checklist covering structure, preconditions, steps, expected results, coverage and independence; best practices for both authors and reviewers; common pitfalls including rubber stamping, gatekeeping and staleness; and how to measure review effectiveness.

### Why Storing Test Cases as Jira Issues Slows Down Your Team

https://getbestest.com/blog/why-jira-issue-bloat-matters/

What Jira issue bloat is and how it happens; the arithmetic (500 test cases times 10 execution cycles produces 5,000+ Jira issues from testing alone); the performance impact on JQL searches, backlog loading and dashboards; backlog pollution and its effect on sprint planning and velocity metrics; which tools cause it (Xray and RTM store tests as Jira issues) and which do not; and migration guidance.

### Best Jira Test Management Tools 2026: A Practical Comparison

https://getbestest.com/blog/best-jira-test-management-tools/

Compares BesTest, Zephyr Scale, Xray, AIO Tests, RTM, and TestRail across architecture, data storage, key features, pros, cons, and pricing, with a comparison table and a decision framework by team size and workflow needs. Includes migration guidance between tools.

### We Thought Our Test Coverage Was Good. Then We Asked Our Own MCP.

https://getbestest.com/blog/mcp-test-management-case-study/

A dogfooding case study. BesTest runs its own QA inside BesTest and connected it to AI agents through MCP. When the agent was asked to build the traceability matrix, the real numbers disagreed with the team's intuition: 79.2% coverage overall, and one shipped feature with zero linked tests. Includes the full workflow and the real data.

### Jira Isn't Made for Testing. But Testing Belongs in Jira.

https://getbestest.com/blog/shift-left-test-right-jira-isnt-made-for-testing/

Chapter 1 of the Shift Left, Test Right series. Teams often take six weeks to roll out a test management tool. This is the opposite: going from a Jira work item to a working, traceable test plan in one sitting.

### Why We Don't Store Test Cases as Jira Issues

https://getbestest.com/blog/shift-left-test-right-why-test-cases-are-not-jira-issues/

Chapter 2 of the Shift Left, Test Right series. Why Jira work items are the wrong shape for test cases, what every workaround costs, and what the team gave up and got back by giving test assets their own home inside Jira.

## Tutorials

Product tutorials at https://getbestest.com/tutorials/

### How to Set Up BesTest in Jira: Getting Started Guide

Installation from the Atlassian Marketplace, initial project configuration via one-click enable, creating a first requirement, writing a first test case, linking requirements to test cases for traceability, running a first execution with the Test Player, reviewing results, and an introduction to Smart Collections. Covers prerequisites, permissions, and the full path from zero to running tests.

### Creating Your First Test Cycle in Jira with BesTest

Test cycle planning (scope, test selection, tester assignment, timeline), creating cycles, selecting test cases manually or through Smart Collections, assigning testers including bulk assignment strategies, executing with the Test Player, logging defects from failed tests, tracking progress through dashboard gadgets and coverage, generating reports, and best practices for focused, achievable cycles.

### How to Set Up Requirements Traceability in BesTest

Why traceability matters, creating and organizing requirements with significance fields (development complexity multiplied by impact), linking test cases to requirements through the Coverage section and the Links tab, understanding the significance-based coverage model and how "covered" is calculated from requirement significance rather than linked test count, using the traceability matrix for release decisions, maintaining traceability as requirements change, and best practices including testable requirements and honest significance settings.

### How to Use Smart Collections to Automate Test Cycles

What Smart Collections are (dynamic rule-based groups of test cases that update themselves), planning a collections strategy with tagging conventions, creating regression and smoke collections step by step, advanced rule combinations, using collections for regression, sprint and smoke workflows, maintaining collections over time, and tips including keeping smoke collections under 25 tests.

### How to Implement Test Case Reviews in BesTest

Why test case review matters, the workflow states (Draft, Ready for Review, In Review, Approved, Changes Requested), submitting test cases for review with a self-review checklist, the reviewer guide and evaluation criteria, using comments and the review audit trail for compliance, best practices for authors, reviewers and leads, and scaling the review process with quality gates so that only approved test cases can be added to test cycles.

## Use Cases

Use case pages at https://getbestest.com/use-cases/

### Regression Testing in Jira

Challenge: identifying which tests to run after changes, maintaining up-to-date regression suites, tracking historical results across releases, ensuring consistent execution.

BesTest solution: Smart Collections with rules such as "all tests tagged regression for the Login module" update themselves as tests change. Structure regression tests in folders by feature, priority, or stability. Track execution history across releases to identify flaky tests and quality trends.

Key benefit: reduces regression cycle setup time by 80% with auto-assembling Smart Collections.

### Smoke Testing in Jira

Challenge: keeping smoke suites small and fast, running them immediately after deployments, giving quick go/no-go feedback.

BesTest solution: Smart Collections with "Tag = smoke" targeting 15-25 critical path tests. The dashboard shows smoke status immediately after execution. If smoke fails, halt further testing; if it passes, proceed.

Best practices: keep to 15-25 tests, target under one hour of execution, run on every deployment, review and prune quarterly.

### User Acceptance Testing (UAT) in Jira

Challenge: non-technical stakeholders unfamiliar with test tools, documenting clear acceptance criteria, tracking sign-off from multiple stakeholders.

BesTest solution: business-friendly test case documentation in non-technical language. Requirements traceability links UAT tests to acceptance criteria. The review workflow enables stakeholder approval before execution. The dashboard shows UAT progress in formats stakeholders understand.

Best practices: involve stakeholders in test creation, use non-technical language, schedule UAT sessions, treat UAT defects as high priority, document sign-off formally for audits.

### Sprint Testing in Jira

Challenge: limited time for test creation and execution within a sprint, tracking which stories are tested, reporting at stand-ups.

BesTest solution: link test cases directly to user stories. Smart Collections auto-include tests for current sprint stories. A real-time dashboard shows sprint testing progress. Test creation is fast in a familiar Jira-native interface.

Best practices: create test cases during sprint planning, test features as they are completed rather than at sprint end, include testing in acceptance criteria, balance new tests with targeted regression.

### API Testing Management in Jira

Challenge: documenting endpoints, methods, and expected responses, managing test data, coordinating manual and automated API tests.

BesTest solution: structured test cases documenting endpoint, method, headers, body, and expected response. Folder organization by microservice or API version. Requirements traceability to integration requirements. Tag automated tests to track automation coverage.

Best practices: include the endpoint URL, method, and expected status code in titles. Document request bodies in preconditions. Test both success and error responses. Keep tests independent.

### Mobile App Testing in Jira

Challenge: multiple platforms, a device and OS version matrix, platform-specific behaviors, app store compliance.

BesTest solution: platform tags (iOS, Android, Both), device matrix documentation in preconditions, cross-platform coverage visibility per requirement, folder structure by platform and feature.

Best practices: test on real devices for final verification, document OS version and device model in results, create separate tests for platform-specific features, test on the oldest and newest supported OS versions.

### Security Testing Management in Jira

Challenge: OWASP and compliance framework alignment, tracking vulnerability remediation, audit trails for compliance.

BesTest solution: create requirements for security controls. Organize tests by OWASP Top 10 categories or CWE classifications. Link tests to security defects for vulnerability tracking. The review workflow supports security test accuracy. Maintain audit-ready documentation.

Best practices: align with OWASP Top 10 and compliance frameworks, document exact reproduction steps, test both positive and negative access scenarios, retest all fixes before closing.

### Test Case Review Workflow

Challenge: unclear or ambiguous test steps, missing preconditions and expected results, duplicate tests, inconsistent quality across team members.

BesTest solution: built-in review workflow with Draft, Review, and Approved states. Assign specific reviewers or let team members pick from a queue. A quality gate prevents unapproved tests from being added to test cycles. Feedback loop for revisions with specific comments. Review audit trail of all approvals.

Key benefit: only approved test cases can be executed, which keeps quality consistent.

## Testing Methodologies

Methodology guides at https://getbestest.com/testing-methodologies/

- **Agile Testing** (https://getbestest.com/testing-methodologies/agile-testing/): Iterative testing embedded in every sprint with continuous feedback and collaboration.
- **Risk-Based Testing** (https://getbestest.com/testing-methodologies/risk-based-testing/): Prioritizing testing effort by risk, meaning likelihood of failure multiplied by impact.
- **Shift-Left Testing** (https://getbestest.com/testing-methodologies/shift-left-testing/): Moving testing earlier in the SDLC through requirements validation and test case reviews.
- **Exploratory Testing** (https://getbestest.com/testing-methodologies/exploratory-testing/): Session-based creative testing that complements scripted test cases.

## Audiences

- **QA Teams** (https://getbestest.com/for/qa-teams/): Structured test management for professional QA teams inside Jira.
- **Engineering Managers** (https://getbestest.com/for/engineering-managers/): Real-time visibility into testing progress, coverage gaps, and release readiness.
- **Startups and Small Teams** (https://getbestest.com/for/startups/): Free test management with one-click setup and no overhead, scaling as the team grows.
- **Regulated Industries** (https://getbestest.com/for/regulated-industries/): Review audit trails, approval workflows, and traceability for compliance-driven testing.

## Glossary

Full glossary at https://getbestest.com/glossary/

**Test Case**: A documented set of conditions and steps used to verify that a software feature works as expected. Components include Test Case ID, Title, Preconditions, Test Steps, Expected Results, Actual Results, and Status (Pass, Fail, Blocked, or Skipped). In BesTest, test cases include a built-in review workflow to ensure quality before execution.

**Test Suite**: A collection of test cases grouped for a specific testing purpose. Can be organized by feature, by type, by priority, or by release. In BesTest, test suites are supported through folder-based organization and Smart Collections for dynamic rule-based grouping.

**Test Cycle**: A single iteration of testing a specific set of test cases, typically associated with a release or sprint. Tracks which tests were run, by whom, when, and with what results. In BesTest, test cycles support real-time progress tracking and historical result analysis.

**Test Execution**: The process of running test cases and recording actual results against expected results. Can be manual, automated, or hybrid. In BesTest, a dedicated test player interface provides fast status updates and defect logging.

**Requirements Traceability**: The ability to link and track requirements through design, development, and testing. Types include forward traceability (requirements to tests), backward traceability (tests to requirements), and bidirectional. It answers the question "has everything we promised been built and tested?". In BesTest, built-in requirements management provides traceability with real-time coverage dashboards.

**Test Coverage**: A measure of how much software or how many requirements are tested. Types include requirements coverage, code coverage, feature coverage, and execution coverage. In BesTest, coverage is significance-based: a requirement counts as covered when it has enough coverage for its significance, rather than simply having one linked test.

**Regression Testing**: Testing that verifies existing functionality still works after code changes. Run after bug fixes, new features, refactoring, and before releases. In BesTest, Smart Collections automatically group regression tests based on tags for targeted execution.

**Smoke Testing**: Quick testing of critical functionality to verify a build is stable enough for further testing. Also called build verification testing. Fast, critical path only, and provides a go/no-go decision. In BesTest, Smart Collections with "Tag = smoke" enable instant smoke cycle execution.

**Defect (Bug)**: A flaw in software that causes incorrect or unexpected behavior. Key attributes include ID, title, description, severity, priority, status, assignee, environment, and steps to reproduce. In BesTest, bugs are created directly from failed test executions with test case context linked automatically.

**Expected Result**: The anticipated outcome of a test step or test case. Must be specific, measurable, unambiguous, and complete. A match with actual results means Pass; a mismatch means Fail. In BesTest, structured fields ensure every test has clear verification criteria.

**Test Plan**: A strategic document outlining testing approach, scope, resources, and schedule. Components include objectives, scope, approach, resources, schedule, risks, entry and exit criteria, and deliverables. In BesTest, test cycles can be organized to align with test plans, with coverage metrics tracking completion.

**Precondition**: The required state or setup before a test case can be executed. Types include user state, data state, system state, and configuration. In BesTest, a dedicated Preconditions field ensures setup requirements are clearly documented.

**Test Automation**: Using software tools and scripts to execute tests automatically without manual intervention. Benefits include speed, consistency, reusability, CI/CD integration, and broader coverage. In BesTest, manual test case management is the current focus, with a REST API for automation integration in closed beta.

**User Acceptance Testing (UAT)**: The final testing phase where actual users or stakeholders verify that software meets business requirements. Business-focused and user-driven, requiring formal sign-off before release. In BesTest, clear test documentation and requirements traceability support UAT workflows.

**Behavior-Driven Development (BDD)**: A development approach describing software behavior in plain language using Given-When-Then (Gherkin) format. Given defines preconditions, When defines the action, Then defines the expected outcome. In BesTest, BDD-style test cases with Given-When-Then format are supported natively.

## Contact and Resources

- Website: https://getbestest.com
- Documentation: https://getbestest.com/docs/
- Email: hello@getbestest.com
- Support: info@btstudio.io
- Help Center: https://bt-studio.atlassian.net/servicedesk/customer/portal/35
- Atlassian Marketplace: https://marketplace.atlassian.com/apps/695702622/bestest-requirement-test-management