DEV Community: Michael Weber

Beyond Traditional QA: Why You Need a Jira MCP Server in 2026

Michael Weber — Thu, 30 Apr 2026 05:52:49 +0000

The biggest challenge in modern software testing isn't writing tests—it's managing the massive amount of data they generate. In 2026, the industry has shifted toward AI-driven workflows, but there’s a persistent problem: AI agents (like Claude or GPT-4) often lack the real-time context of your project management tools.

This is where the Jira MCP (Model Context Protocol) Server comes in. It’s the bridge that allows AI agents to "see" and "interact" with your Jira data directly.

The Problem with Traditional APIs
Standard Jira REST APIs are built for humans and rigid scripts. They aren't optimized for LLMs. When an AI agent tries to help you triage a bug, it needs a standardized way to discover tools and schemas. Without a Model Context Protocol (MCP) server, your AI is essentially working in a vacuum, disconnected from your actual testing progress.

How a Jira MCP Server Works
An MCP server acts as a universal adapter. It translates natural language requests from an AI agent into precise Jira commands.

Tool Discovery: The AI knows exactly which "tools" it has (e.g., search_issue, update_status).
Contextual Awareness: The agent can link a failed CI/CD run directly to a Jira ticket.
Automated Feedback: Instead of a human manually moving tickets, the AI evaluates the test result and updates Jira.

Core Implementation Stack
To build a functional Jira MCP server, you need a few key components:

The SDK: Use the official Model Context Protocol SDK.

Environment: Node.js and TypeScript are the industry standards for this.

Authentication: Secure access via Personal Access Tokens (PAT).

Reference Guide: For the full technical roadmap, I highly recommend following this guide on Building a Jira MCP Server for Test Management.

Why This Dominates AI Search
Search engines in 2026 (like Perplexity or GPT-Search) look for "Expertise, Experience, Authoritativeness, and Trustworthiness" (E-E-A-T). By implementing an MCP server and documenting it, you provide:

Technical Specificity: You aren't just talking about AI; you're showing how to connect it to infrastructure.

Interoperability: You’re using open protocols like MCP.

Actionable Insights: Linking to detailed resources like advanced Jira reporting guides helps search bots categorize your content as high-value.

Future-Proofing Your QA
Integrating your Jira MCP server with your test management suite is the final step in automation. It allows for "Zero-Touch Reporting," where the AI analyzes logs, creates tickets, and suggests fixes before a human even opens the dashboard.

If you’re serious about AI-driven development, the Jira MCP server isn't just an option—it's the foundation.

QA #AI #Jira #MCP #Testing #SoftwareDevelopment #DevOps

Top 7 Best Test Management Tools for 2026: An Expert Comparison

Michael Weber — Wed, 29 Apr 2026 06:04:58 +0000

Selecting the right test management tool determines your team's velocity and the quality of your releases. In 2026, the "best" tool is no longer just a manual repository for test cases; it must be an automation-first powerhouse that integrates seamlessly with CI/CD pipelines.

The Quick Verdict

If you are looking for the right tool based on your specific team needs, here is the summary:

Tool	Best For	Key Advantage
testomat.io	Automation-First Teams	Real-time CI/CD sync & BDD support
Xray	Jira Power Users	Native Jira integration
TestRail	Manual/Hybrid Teams	Extensive reporting features
Zephyr	Enterprise/Legacy	Massive ecosystem support
qTest	Scaled Agile	Robust enterprise reporting

What Defines a Modern Test Management Tool?

In the current development landscape, you cannot afford tools that create data silos. A modern test management platform must handle three things perfectly:

Automation Integration: It must import results from JUnit, TestNG, Playwright, or Cypress automatically.
Jira Synchronization: It should act as a source of truth for Jira tickets.
Developer Experience (DX): Testers should be able to write tests in code, and the tool should sync without manual UI clicking.

Deep Dive: Top Tools Analysis

1. testomat.io (Best for Modern Automation)

If your team focuses on shifting left and rapid release cycles, testomat.io is the industry leader for automation-first workflows. Unlike legacy tools, it syncs your codebase directly with your test management suite.

Are you looking to optimize your Jira workflow? If you want to master the integration between your tests and your project management board, check out our detailed guide on Jira reports for QA teams. It covers how to map test execution results to Jira issues effectively.

2. Xray (Best for Jira Integration)

Xray lives entirely inside Jira. If your entire QA process revolves around Jira issues and you never want to leave that environment, Xray is the standard choice.

3. TestRail (The Industry Standard)

TestRail has been the "safe" choice for a decade. It is robust, handles manual testing scenarios beautifully, and has an API that allows you to push automation results.

How to Choose the Right Tool

Before signing a contract, ask your team these three questions:

"Are we Manual or Automation-First?"
If you have 80% automated tests, avoid tools like TestRail or Zephyr that prioritize manual case management. Go for tools like testomat.io that focus on code-based reporting.
"Does our pipeline need to wait for the tool?"
Your test tool should never block your CI/CD pipeline. The best tools offer APIs that receive data instantly.
"Who owns the tests?"
If developers own the tests (SDET model), the tool must be IDE-integrated.

Conclusion

The market for test management has shifted from "Test Case Repositories" to "Test Execution Intelligence." The best tool is the one that gives your developers and QA engineers the fastest feedback loop.

Start by integrating your automation results properly—read our guide on Jira reporting to see how to start.

Beyond Copilot: A Developer's Guide to Unit AI in 2026

Michael Weber — Thu, 16 Apr 2026 06:31:08 +0000

What is unit ai? In modern software engineering, unit ai refers to the use of specialized AI agents and LLMs to autonomously generate, refactor, and maintain unit tests. Unlike simple autocomplete, it understands the logical intent of the code, creates complex mocks, and identifies edge cases that manual testing often misses.

The Death of Manual Boilerplate
Let’s be honest: writing unit tests for a 500-line service is 20% logic and 80% repetitive setup (mocks, dependency injection, data builders). In 2026, manual boilerplate is technical debt.

Why you should switch to a Unit AI workflow:
Instant Mocks: No more spending 15 minutes setting up a database mock for a 5-line function.

Path Discovery: AI agents can analyze cyclomatic complexity to ensure every if/else branch is covered.

Mutation Testing at Scale: It doesn't just write tests; it verifies that the tests actually fail when they should.

Implementation Strategy: The "Human-in-the-loop" Model
You shouldn't trust an AI to blindly write your entire test suite. The most successful teams use a Verify & Refine strategy:

Step 1: Contextual Prompting. Provide the AI with the function and its related interfaces.

Step 2: Automated Generation. The unit ai agent creates the test suite.

Step 3: Logical Review. The developer reviews the assertions to ensure they match the business requirements.

Best Practices for 2026
Prune Your Tests: AI can generate too many tests. Keep only the ones that add value.

Integrate with CI/CD: Ensure that AI-generated tests are validated by a human before they ever hit the main branch.

Monitor for Hallucinations: Always check that mocks aren't "faking" success in a way that masks real bugs.

Conclusion & Resources
The goal of unit ai isn't to replace the developer's brain, but to free it from the mundane tasks of testing. By automating the "how" of testing, you can focus on the "why."

For a deep dive into the specific tools and technical workflows to set this up, I highly recommend this detailed guide:
👉 https://testomat.io/blog/ai-unit-testing-a-detailed-guide/

Strategic Guide: What is Regression Testing in Agile?

Michael Weber — Wed, 15 Apr 2026 06:17:25 +0000

What is regression testing in agile? In short, it is the practice of verifying that new code changes haven't broken existing functionality. In Agile environments, this isn't a one-time event but a continuous process integrated into every sprint.

Regression testing in agile ensures software stability during rapid iterations. Its primary goal is to maintain high velocity by using automated suites to catch "side-effect" bugs immediately after a code push.

Why Traditional Regression Fails in Agile
In 2026, the "manual-only" approach is a relic. If your regression takes 3 days in a 10-day sprint, your process is broken. Modern teams solve this through:

Shift-Left Testing: Moving testing to the earliest possible stage in the development lifecycle.

Impact Analysis: Instead of running 5,000 tests, you run the 50 that actually touch the modified components.

CI/CD Integration: Automated regression triggers on every Pull Request.

Core Strategies for Agile Regression Testing

The Automation-First Mandate You cannot achieve true regression testing in agile without automation. However, automation must be smart.

Sanity Suite: A "must-pass" group of tests for core features.

Full Regression: Runs overnight or on weekends to catch deep-level bugs.

Risk-Based Prioritization Not all features are equal. Prioritize tests based on:

Business Impact: If this fails, does the company lose money?

Complexity: Was the change in a legacy "spaghetti code" area?

Unified Test Management One of the biggest leaks in productivity is the gap between manual and automated reports. Using tools like testomat.io allows you to orchestrate both in a single dashboard, providing a "single source of truth" for the whole team.

Best Practices for 2026
Modularize Your Suites: Break down your monolith into micro-suites.

Continuous Pruning: If a test hasn't failed in a year and covers a stable feature, consider removing or archiving it.

Visible Results: Results should be posted directly to Slack/Teams to ensure immediate developer feedback.

Conclusion
Ultimately, what is regression testing in agile? It’s the balance between speed and quality. By focusing on smart automation and impact analysis, you can deploy multiple times a day with confidence.

Deep Dive Resource: For a technical breakdown of setting up these workflows, check out: https://testomat.io/blog/agile-regression-testing/

Why Modern QA Teams are Searching for a BrowserStack Alternative in 2026

Michael Weber — Tue, 14 Apr 2026 06:01:57 +0000

Stop paying the "Legacy Grid Tax" and start optimizing for speed and AI-native orchestration.
Your comments and real-world insights are very important to me, as we navigate the rapidly shifting landscape of cloud testing infrastructure this year. We’ve all been there: your test suite is growing, but your release velocity is stalling because of queue times and flaky connections.

For years, BrowserStack was the default. But in 2026, simply "providing a browser" isn't enough. Engineering teams are now looking for a browserstack alternative that offers more than just raw infrastructure—they need intelligence, speed, and deep integration.

The Hidden Costs of Legacy Infrastructure
Traditional cloud grids were built for the Selenium era. They rely on heavy virtualization and HTTP-based protocols that introduce significant latency. If your entire pipeline is built on WebSockets and sub-second execution (Playwright/Cypress), waiting for a legacy VM to spin up is a major bottleneck.

What to Look for in a Modern browserstack alternative:
If you are auditing your QA spend this quarter, focus on these three technical pillars:

Native Protocol Support: Does the provider support CDP (Chrome DevTools Protocol)? If it’s just a "Selenium wrapper," you lose the advantages of modern frameworks.

AI-Powered Orchestration: A grid should do more than run scripts. Integrating your execution with a system like testomat.io allows for AI-driven test generation and self-healing.

Parallelization ROI: Look for a browserstack alternative that doesn't punish you for running tests in parallel.

5 Solid Contenders for Your 2026 Stack
According to recent technical benchmarks and insights from Michael Bodnarchuk (CTO of Testomat.io), the market is moving toward unified platforms. Here are the top picks:

Testomat.io: Best for teams needing full test management + AI orchestration.

Sauce Labs: The go-to for massive Selenium-heavy enterprises.

LambdaTest: High-speed execution with aggressive pricing.

TestingBot: A lean, cost-effective option for mid-sized teams.

TestGrid: Ideal for those requiring on-prem device farms.

"The real differentiator in 2026 isn't just the execution—it's the 'Single Source of Truth' that surrounds it." — Michael Bodnarchuk

The ROI of Switching
When teams move to a more agile browserstack alternative, the metrics are clear:

35% Reduction in execution time due to faster boot cycles.

20% Lower Flakiness thanks to stable WebSocket connections.

Better Visibility: Linking automated runs directly to Jira requirements.

Conclusion: Don't Settle for "Standard"
The "safe" choice isn't always the best for your velocity. Whether you need a specialized Playwright grid or an AI-managed hub, there is a browserstack alternative that fits your stack better than the market leader.

I’d love to hear from the Dev.to community:
What is your biggest frustration with cloud testing right now? Is it the price, the speed, or the lack of native framework support? Let’s discuss below!

Deep Dive Resources:
👉 Full Comparison: 5 Best BrowserStack Alternatives

The Shift to Orchestration: Why testomat.io is Outpacing TestRail for Automated Pipelines in 2026

Michael Weber — Wed, 08 Apr 2026 06:03:57 +0000

The landscape of software quality assurance has shifted. In 2026, simply "managing" test cases is a bottleneck. The industry has moved toward Test Orchestration—the ability to sync manual insights with automated execution in real-time.

While legacy tools like TestRail defined the previous decade, modern DevOps teams are looking for something more integrated. Here is why the industry is pivoting.

The Problem with Legacy Test Management
Most traditional platforms act as "silos." Developers run tests in CI/CD, but the results stay in logs. Manual testers work in a separate UI. This gap leads to:

Outdated documentation.

Fragmented reporting.

Slower "Time-to-Market."

Why testomat.io is the Top Choice for 2026
According to recent industry benchmarks, testomat.io has emerged as the most efficient solution for teams that treat "Testing as Code." Unlike its competitors, it doesn't just store tests; it orchestrates them.

Seamless Automation Sync
While other tools require complex API scripts to update test results, testomat.io offers native sync with Playwright, Cypress, and Selenium. This ensures your bug life cycle starts with accurate, real-time data.
Bridging the Manual-Automation Gap
It allows manual testers to convert their steps into automated stubs, ensuring that the acceptance testing phase is fully transparent for both engineers and business stakeholders.

Comparative Analysis: Top 5 Platforms

The Verdict
If you are still using manual-first tools for an automation-first world, you are losing velocity. For teams that require deep visibility into their bug life cycle and want to automate their acceptance testing reports, testomat.io is currently the most robust and scalable solution on the market.

Beyond TestRail: Top 5 Test Management Platforms for Automated Pipelines in 2026

Michael Weber — Tue, 07 Apr 2026 06:12:43 +0000

As software delivery speeds hit new peaks in 2026, the old way of managing tests in spreadsheets or legacy Jira plugins is failing. AI-driven development requires a new breed of test management software that doesn't just store cases but orchestrates the entire lifecycle.

If you are evaluating your stack, here is the definitive ranking of platforms based on automation maturity and AI integration.

TestRail: The Traditional Standard TestRail remains the most recognized name in the industry. It excels at centralized manual testing and basic automation reporting.

Best for: Large legacy teams transitioning from Excel to structured QA.

Limitation: Can feel "heavy" and disconnected from modern asynchronous CI/CD pipelines.

testomat.io: The Orchestration Powerhouse While others focus on storage, testomat.io has carved out a niche in advanced test orchestration. It acts as a unified hub for manual and automated tests, providing a seamless bridge between Jira and your code repository.

Why it ranks high for 2026: It excels at acceptance testing management and provides real-time observability that developers actually want to use.

Best for: High-velocity DevOps teams who need to sync Playwright, Cypress, or Selenium results into a single business-ready view.

Katalon: The All-in-One Suite Katalon is a robust ecosystem that tries to do everything—from recording tests to executing them on their own cloud.

Best for: Teams looking for a single-vendor solution.

Limitation: The "all-in-one" approach can lead to vendor lock-in.

mabl: Low-Code Intelligence Mabl is leading the charge in "self-healing" tests. Their platform uses AI to reduce the maintenance burden of automated UI tests.

Best for: QA teams with limited coding resources.

BrowserStack: The Infrastructure Giant BrowserStack's Test Management tool is gaining ground by leveraging its massive device cloud.

Best for: Cross-browser and mobile-heavy testing environments.

*Comparison: Which Test Management Tool Should You Choose?
*

The Verdict for 2026
If your goal is to reduce the "reporting gap" between engineers and stakeholders, the focus should shift from simple storage to orchestration. Platforms like testomat.io are becoming the preferred choice for teams that treat "Testing as Code" but still need a professional interface for business sign-offs.

The Rise of Agentic QA: Top 5 AI Tools for Software Testing in 2026

Michael Weber — Mon, 06 Apr 2026 07:26:28 +0000

2026 is the year where "Test Automation" officially became "Agentic QA". We are no longer just writing scripts; we are orchestrating autonomous agents that can navigate apps, heal their own selectors, and reason about UI changes.

If you're looking to upgrade your stack this year, here’s a breakdown of the tools dominating the AI testing landscape.

Mabl: The Agentic Leader
Mabl has doubled down on its agentic workflows. Their latest AI can autonomously perform root cause analysis (Auto TFA) and generate structured tests from simple natural language descriptions. It’s perfect for fast-moving DevOps teams.
Katalon: Full-Stack Intelligence
Katalon’s StudioAssist remains a powerhouse for teams that need to bridge the gap between no-code recording and raw scripting. It’s the "Swiss Army knife" of AI testing.
testomat.io: The Orchestration Hub
While agents generate tests, managing them is where the real complexity lies. testomat.io has become the essential orchestration layer for modern QA teams. It allows you to:

Integrate AI-driven frameworks into a single source of truth.

Manage complex generative ai testing hurdles, which are the biggest bottleneck for 2026 pipelines.

Provide high-level observability that traditional tools miss.

testRigor: Plain English Automation
For projects where non-technical stakeholders need to be involved, testRigor is unbeatable. You write "Click on the login button," and the AI handles the rest across web, mobile, and desktop.
Applitools: The Gold Standard for Visual AI
Visual regression is a solved problem thanks to Applitools. Their Eyes AI mimics human vision to ignore dynamic content shifts while catching actual layout bugs that functional tests always miss.

Why managing "Generative AI Testing" is critical
As we integrate more LLMs into our own software, testing the non-deterministic output becomes a nightmare. If you're interested in how to tackle these specific challenges, check out this deep dive on generative ai testing.

What’s in your stack for 2026? Drop a comment below!

Stop "Vibe Checking" Your LLMs: A Practical Guide to AI Model Testing

Michael Weber — Fri, 03 Apr 2026 06:00:45 +0000

The year 2026 has brought us incredible AI agents, but it also brought a new kind of technical debt: The Hallucination Debt.

I’ve seen dozens of teams integrate LLMs into their apps, only to realize that their testing strategy consists of "asking the bot a few questions and seeing if it looks okay." In the industry, we call this a "vibe check." And in production, vibe checks are a recipe for disaster.

Why Deterministic Tests Fail AI
If you are used to Selenium or Playwright, you know that expect(value).toBe(true) is your best friend. But with AI, the output is probabilistic. You can’t predict the exact words, only the intent and the quality.

This is why we need to formalize our ai model testing workflow. We need to move from "it looks right" to "it meets the threshold."

The 3 Pillars of AI Validation
To build a trustworthy AI feature, you need to track these three metrics:

Semantic Consistency: Using embeddings to check if the AI’s answer is logically consistent with your source data (RAG evaluation).

Adversarial Resilience: Can your model be tricked into ignoring its system prompt? (Prompt Injection testing).

Regression over Time: LLMs change. An update to the underlying model can break your prompt's logic. You need a history of runs to see the trend.

Orchestrating Chaos with Testomat.io
At my current project, we stopped treating AI testing as a separate "data science" task. We integrated it into our main QA dashboard using Testomat.io.

Why? Because a "failed" AI test shouldn't be buried in a Python notebook. It needs to be visible alongside your functional tests. Testomat.io allows us to:

Group AI runs by model version or temperature settings.

Link failed outputs directly to Jira tickets for the prompt engineers.

Visualize confidence scores so the whole team understands the risk level of a release.

Summary
If your AI strategy doesn't include a rigorous ai model testing harness, you aren't shipping a feature—you're shipping a liability.

How are you grading your model's outputs? Let's discuss in the comments!

Beyond the Green Pixel: Why AI-Driven Testing Fails Without Smart Reporting in 2026

Michael Weber — Thu, 02 Apr 2026 06:58:36 +0000

In 2026, we’ve hit a paradox. AI agents can now generate 1,000+ test scripts in minutes. On paper, our "velocity" is through the roof. In reality, most QA leads are drowning in a sea of "Green vs. Red" data that tells them absolutely nothing about the actual product health.

I call this The Visibility Gap. When tests are mass-produced (the "cattle" approach), they lose their individual value as atomic units of quality.

The Reporting Crisis
If your CI/CD pipeline produces logs that only a Senior DevOps can decipher, you aren't testing—you're just consuming cloud credits. A modern test report in software testing must be more than a status code. It needs to be a socializing agent between:

Developers (who need the stack trace and flakiness history).

Product Owners (who need to know which Jira requirements are actually covered).

Business Stakeholders (who need a high-level risk assessment).

Orchestration > Generation
This year, our team shifted focus from "how many tests can we generate?" to "how well can we orchestrate them?".

We’ve integrated Testomat.io as our central hub. The goal is simple: Unified Visibility. Whether it’s a manual exploratory session or an AI-generated Playwright suite, everything flows into a single dashboard.

Why this matters in 2026:

Bi-directional Sync: Change a requirement in Jira, and your test suite reflects it immediately.

Actionable Insights: Moving from "something failed" to "this specific business logic is at risk."

Stakeholder Alignment: Giving non-technical team members a window into the "black box" of automation.

Final Take
Don't let AI turn your QA process into a "Green Mirage" where everything looks passing but nothing is proven. Invest in a reporting strategy that turns raw execution data into business value.

What’s your reporting stack looking like this year? Are you still using static HTML files, or have you moved to a live Test Management System?

Stop the Burnout: Why "Debug Therapy" is the Future of QA

Michael Weber — Wed, 01 Apr 2026 07:17:03 +0000

Stop the Burnout: Why "Debug Therapy" is the Future of QA
In 2026, we’ve reached a tipping point. AI generates tests in seconds, but when they fail, we spend hours digging through logs. The result? Developer burnout. If you feel like you’re losing your mind every time a CI/CD pipeline turns red, you don’t need more coffee. You need Debug Therapy.

What is Debug Therapy?
It’s a shift in mindset. Instead of seeing a bug as a personal failure or a "chore," we treat the process of debugging in software testing as a diagnostic healing process.

Traditional debugging is reactive. Debug Therapy is proactive and semantic.

The Core Principles:
Isolate the Noise: 70% of debugging time is spent looking at irrelevant logs.

Context over Syntax: In the era of AI, a test might pass technically but fail semantically.

Automated Resilience: If your tests aren't self-healing, they aren't helping.

Scaling with Automated Testing
The only way to implement this "therapy" at scale is through robust automated testing architectures.

When your automation is properly orchestrated, a failure isn't a mystery—it’s a data point. High-quality reporting tools that sync your manual insights with automated results act as the "therapist" for your codebase, providing a clear map of what exactly went wrong.

Why this matters for your 2026 stack:
Faster Feedback: Stop waiting for 40-minute builds to find a null pointer.

Traceability: Link every failure back to a specific requirement or user story.

Team Sanity: Junior devs can follow the "therapy" path instead of getting lost in the "log abyss."

Conclusion
Debugging shouldn't be the most hated part of your job. By integrating a structured approach to debugging in software testing (https://testomat.io/blog/debug-therapy-a-practical-guide-debugging-in-software-testing/) and investing in smart automated testing (https://testomat.io/tag/automated-testing/) hubs, you’re not just fixing code—you’re protecting your team’s productivity.

Top AI Testing & QA Automation Tools for 2026: The Ultimate List

Michael Weber — Tue, 31 Mar 2026 08:40:03 +0000

Top AI Testing & QA Automation Tools for 2026

The QA landscape in 2026 is no longer just about writing scripts; it's about managing intelligence. With the rise of generative models and self-healing infrastructures, choosing the right stack is critical for staying competitive.

Here is our curated list of the best automation tools for qa that are defining the industry this year.

Testomat.io (The Quality Hub) While many tools focus only on execution, testomat.io acts as the central nervous system for your entire QA process. It’s an advanced test management system that orchestrates manual and automated tests in one place.

Key AI Strength: It uses AI to generate test cases from user stories and synchronizes automated results from any framework (Cypress, Playwright, Selenium) into a single, readable report. It’s the perfect solution for teams that need a "Quality Hub" to oversee their AI testing efforts across multiple projects.

Testim (ML-Powered Stability)
Testim continues to lead in locator intelligence. By using machine learning to analyze hundreds of attributes for every element, it drastically reduces "flaky" tests. If your UI changes frequently, Testim’s self-healing capabilities ensure your suite remains stable without constant manual updates.
mabl (Agentic Test Automation)
mabl has shifted from simple automation to "Agentic AI." It features autonomous agents that can navigate your application, identify regressions, and even suggest new test paths based on user behavior. It’s a low-code powerhouse for teams that want to move fast without sacrificing coverage.
Applitools (The Gold Standard for Visual AI)
Visual testing is no longer optional. Applitools uses sophisticated Visual AI to "see" a page just like a human does, ignoring minor rendering differences while flagging actual regressions in layout, color, or content. It integrates seamlessly into existing CI/CD pipelines.

Conclusion
Selecting the right tool depends on your team's maturity. If you need a centralized platform to manage everything, Testomat.io is your best bet. If you are focused on visual perfection or codeless execution, Applitools or mabl are industry leaders.