10 Key Automation Testing Advantages for 2025

In today's fast-paced software development landscape, speed and quality are non-negotiable. Manual testing, while valuable for exploratory checks, often creates significant bottlenecks that slow down release cycles and increase operational costs. This is precisely where automation testing transforms the entire development lifecycle. By automating repetitive, time-consuming, and complex checks, teams can achieve faster feedback loops, broader test coverage, and ultimately, higher-quality releases. This strategic shift is no longer a luxury; it's a fundamental necessity for staying competitive and delivering reliable products.

Throughout this comprehensive list, we'll explore the critical automation testing advantages that empower teams to ship better software, faster. Each point will provide actionable insights into how you can implement these benefits within your own workflows. We'll also highlight how modern tools, such as API mocking platforms like dotMock, amplify these benefits by creating stable and predictable test environments. This is especially crucial when dealing with unreliable third-party APIs or services that are not yet fully developed.

As automation becomes indispensable, understanding advanced techniques is key to maximizing its impact. Further insights into next-generation strategies can be found in a discussion on the top benefits of AI in software testing, which complements the foundational advantages we will cover here.

1. Increased Test Coverage and Speed

One of the most significant automation testing advantages is the ability to execute a vast number of test cases in a fraction of the time required by manual efforts. Automated scripts can run continuously, 24/7, and in parallel across different environments, browsers, and devices. This allows teams to achieve comprehensive test coverage over functionality, performance, and security without a proportional increase in time or resources.

This accelerated feedback loop is crucial for modern development practices like Continuous Integration and Continuous Delivery (CI/CD), where rapid validation is a necessity for frequent deployments. For instance, tech giants like Google and Amazon leverage this principle to run millions of automated tests daily, ensuring product stability across countless configurations.

Unlocking Speed with Service Isolation

A common bottleneck in integrated environments is dependency on other services. If a backend API is slow, under development, or temporarily unavailable, it can halt entire test suites. This is where API mocking tools become invaluable.

By using an API mocking tool like dotMock, teams can simulate API responses and test components in complete isolation. This decouples dependencies, allowing front-end and microservices tests to run consistently and quickly, regardless of the actual backend's status.

How to Implement for Maximum Impact

To effectively leverage the speed and coverage benefits of automation, follow these actionable steps:

• Prioritize Tests: Start by automating test cases for high-value, critical, and frequently used application features. This ensures you get the most significant return on your initial automation investment.
• Implement Parallelization: Configure your test runner (like TestNG or JUnit) to execute tests simultaneously rather than sequentially. This drastically reduces the total execution time for your test suite.
• Leverage Cloud Infrastructure: Use cloud-based testing platforms to run tests across a wide array of browsers, operating systems, and device configurations without maintaining the physical hardware.
• Establish Baselines: Before scaling up, run your initial automated suite to create performance and coverage benchmarks. Use these metrics to track improvements and identify regressions over time.

2. Cost Reduction Over Time

While automation testing requires an initial investment in tools, infrastructure, and skilled resources, it delivers substantial long-term cost savings. This key automation testing advantage stems from reducing manual labor, accelerating time-to-market, and minimizing expensive post-release defects. Companies like IBM have reported a 2.5x return on investment from their automation efforts, proving its financial viability.

The primary saving comes from reallocating human resources away from repetitive, time-consuming regression tests to more strategic, high-value tasks like exploratory testing. By catching bugs earlier in the development cycle, automation also prevents them from escalating into costly production issues that can damage revenue and brand reputation.

Mitigating Costs with Efficient Testing

A significant hidden cost in testing is the time developers and QA teams spend waiting for dependent services or troubleshooting environment-specific failures. These delays directly translate to higher labor costs and slower delivery timelines, eroding potential ROI.

By simulating unavailable or slow third-party APIs with a tool like dotMock, teams can eliminate costly environmental dependencies. This ensures that test suites run predictably and without interruption, allowing developers to validate features faster and reducing wasted engineering hours spent on debugging flaky infrastructure.

How to Implement for Maximum Impact

To ensure your automation strategy delivers a strong return on investment, focus on these practical steps:

• Prioritize High-Frequency Scenarios: Begin by automating tests for business-critical and frequently executed workflows. This ensures the most repetitive manual tasks are eliminated first, yielding the quickest cost savings.
• Leverage Open-Source Tools: Mitigate initial licensing fees by building your framework with powerful, community-supported open-source tools like Selenium, Playwright, or Cypress.
• Train Existing QA Staff: Invest in upskilling your current manual testers in automation practices. This is often more cost-effective than hiring specialized automation engineers and empowers your entire team.
• Calculate Total Cost of Ownership (TCO): Look beyond the initial tool costs. Factor in maintenance, training, and infrastructure expenses to get a realistic picture of your long-term investment and ROI.

3. Enhanced Accuracy and Consistency

One of the core automation testing advantages is the elimination of human error. Unlike manual testers who can suffer from fatigue, oversight, or subjective interpretation, automated scripts execute the exact same steps with the same data every single time. This unwavering consistency ensures that test results are reliable, repeatable, and free from the variables that plague manual efforts.

This level of precision is non-negotiable in industries where a minor error can have major consequences. For instance, financial services firms rely on automation for regulatory compliance validation, while healthcare systems use it to verify the integrity of critical patient data. The tests validate precise expected outcomes without any room for ambiguity, making defect detection far more accurate.

Guaranteeing Reliability with Data-Driven Testing

A common challenge is ensuring tests are not just consistent but also thorough. A test that always uses the same simple input might be consistent but misses potential bugs. This is where data-driven testing becomes a powerful technique for enhancing accuracy.

By separating the test logic from the test data, teams can run the same test script against hundreds of different data sets, including edge cases and invalid inputs. This approach ensures that functionality is robust and accurate across a wide spectrum of real-world scenarios.

How to Implement for Maximum Impact

To leverage automation for superior accuracy and consistency, focus on these actionable steps:

• Use Descriptive Assertions: Implement assertion libraries (like Chai or AssertJ) that provide clear, detailed error messages upon failure. This pinpoints the exact cause of a discrepancy, speeding up debugging.
• Create Diverse Test Data: Build comprehensive test data sets that cover positive scenarios, negative scenarios, and critical edge cases to ensure your application behaves correctly under all conditions.
• Version Control Your Scripts: Store all test scripts and related artifacts in a version control system like Git. This provides a full history of changes, making it easy to track modifications and revert if necessary.
• Generate Detailed Reports: Configure your test framework to produce comprehensive reports (in HTML or PDF format) with logs and screenshots. These artifacts provide objective proof of test outcomes for all stakeholders.

4. Faster Feedback and Early Bug Detection

A core advantage of automation testing lies in its ability to provide immediate feedback on code changes. By integrating automated tests into the development pipeline, developers can identify and fix defects within minutes of a code commit, rather than days or weeks later. This rapid validation loop is a cornerstone of modern software development, catching bugs early in the cycle when they are significantly cheaper and less complex to resolve.

This "shift-left" approach, championed by the DevOps movement, moves testing earlier into the development process. For instance, platforms like GitHub and GitLab leverage this by automatically running test suites against every pull request, preventing buggy code from ever being merged. This ensures a constant state of high quality and drastically reduces the time spent on manual regression testing later. To learn more about this transformative approach, explore the concept of shift-left testing.

Unlocking Speed with Service Isolation

External service dependencies are a common cause of slow and flaky test suites, delaying crucial feedback. When a test relies on a live API that is slow or unavailable, it can fail for reasons unrelated to the code change being tested, creating noise and slowing down developers. This is where API virtualization tools become essential for maintaining a fast feedback loop.

By using an API mocking tool like dotMock, teams can simulate API behaviors and data. This allows developers to run tests against a stable, predictable, and instantly available mock service, eliminating external dependencies and ensuring that test failures point to real issues in the new code.

How to Implement for Maximum Impact

To create a fast and effective feedback loop with automated testing, follow these actionable steps:

• Integrate with CI/CD: Connect your automated test suite to your Continuous Integration platform (like Jenkins, GitLab CI, or GitHub Actions) to trigger tests automatically on every code commit.
• Maintain Fast Suites: Categorize your tests by execution time. Aim to keep your core "commit-stage" test suite running in under 10 minutes to provide near-instant feedback.
• Configure Immediate Notifications: Set up alerts through tools like Slack or email to notify the relevant team members immediately upon a test failure, enabling a swift response.
• Set Aggressive Timeouts: Configure timeouts for individual tests and the overall suite to prevent a single slow test from blocking the entire feedback pipeline.

5. Improved Test Documentation and Traceability

One of the most overlooked automation testing advantages is that well-written test suites serve as living, executable documentation. Unlike static documents that quickly become outdated, automated test scripts describe precisely how the system is expected to behave under specific conditions. This creates an accurate, always up-to-date reference that remains perfectly synchronized with the application's actual functionality.

This approach is invaluable for onboarding new developers, clarifying requirements between technical and non-technical stakeholders, and ensuring regulatory compliance. For instance, financial institutions leverage automated test outputs as auditable proof that their systems meet strict regulatory standards, while companies like Toyota use Behavior-Driven Development (BDD) frameworks to turn test cases into readable specifications.

Bridging the Gap with Mock Data

Traceability breaks down when inconsistent or unavailable test data prevents tests from running, creating gaps in documentation. If a test relies on a specific API response to document a business rule but the API is down, that piece of documentation becomes unverifiable.

Using an API mocking tool like dotMock ensures that tests can run with consistent, predefined data payloads. This allows teams to create reliable, self-documenting tests for every scenario, including edge cases and error conditions, without depending on live services.

How to Implement for Maximum Impact

To transform your test suite into a reliable source of documentation, follow these actionable steps:

• Adopt BDD Frameworks: Use tools like Cucumber or SpecFlow to write tests in a human-readable, Gherkin syntax (Given-When-Then). This makes the test's purpose clear to everyone on the team.
• Use Descriptive Naming Conventions: Name your tests to clearly describe the scenario they cover. For example, a test named shouldReturnErrorWhenPasswordIsIncorrect is far more descriptive than loginTest2.
• Generate Comprehensive Reports: Configure your test runner to automatically generate reports that include screenshots, logs, and even video recordings of test executions, providing visual proof of application behavior.
• Integrate with Management Tools: Link your automated tests directly to user stories or requirements in a test management platform. This creates end-to-end traceability from requirement to implementation. Learn more about effective test case management to streamline this process.

6. Scalability and Support for Continuous Integration/Deployment

Another critical automation testing advantage is its inherent ability to scale alongside your development efforts. As an application grows in complexity, manual testing becomes a bottleneck, requiring a linear increase in human resources. Automation, however, allows testing efforts to expand efficiently, forming the foundational support structure for modern Continuous Integration and Continuous Deployment (CI/CD) pipelines.

This integration empowers teams to ship code with confidence, as every change automatically triggers a comprehensive suite of tests. This constant validation is what enables tech leaders like Netflix and Etsy to deploy hundreds or even thousands of times per day while maintaining stringent quality gates. To ensure efficient and high-quality releases, integrating automation testing is a vital part of modern software development best practices, including CI/CD and testing, essential for remote teams.

Scaling with Service Virtualization

In a CI/CD pipeline, tests must run reliably and without external friction. Dependencies on third-party APIs or unstable staging environments can introduce flakiness and delays, breaking the entire delivery flow. Service virtualization eliminates this risk by replacing real dependencies with stable, virtual counterparts.

By simulating external services, tools like dotMock create a predictable and self-contained testing environment. This allows your CI pipeline to run tests for any scenario, from successful API calls to network failures, without relying on live, external systems. Learn more about optimizing your CI pipeline with these techniques.

How to Implement for Maximum Impact

To build a scalable testing framework that powers your CI/CD pipeline, focus on these strategies:

• Containerize Test Environments: Use Docker to create consistent, reproducible environments for your tests. This eliminates the "it works on my machine" problem and ensures reliability within the CI pipeline.
• Adopt Cloud Testing Platforms: Leverage services like BrowserStack or Sauce Labs to run tests in parallel across a massive grid of browsers and devices without managing the infrastructure yourself.
• Implement Test Sharding: Distribute your test suite across multiple machines or containers to run them concurrently. This technique, also known as test parallelization, drastically cuts down execution time.
• Prioritize API-Level Tests: Focus a significant portion of your automation effort on API tests. They are faster and more stable than UI tests, providing quicker feedback in the pipeline.

7. Better Risk Management and Compliance

For organizations in regulated industries, one of the most compelling automation testing advantages is the ability to enforce stringent risk management and compliance standards. Automated tests generate consistent, repeatable, and fully documented evidence of system validation, which is essential for audits. This creates a detailed, immutable trail that proves systems operate as intended and meet regulatory requirements.

This capability is non-negotiable for sectors where compliance is mandatory. For instance, financial services firms rely on automation to validate systems against PCI-DSS and SOX requirements, while pharmaceutical companies use it to generate the validation documentation required by the FDA. The detailed logs and consistent execution provide an objective, auditable record that manual testing cannot match.

Isolating Components for Focused Compliance Checks

In complex systems, proving that a specific component meets a compliance rule can be difficult due to interconnected dependencies. If an external service fails or provides inconsistent data, it can invalidate a compliance-focused test run, creating noise and uncertainty in audit trails.

Using an API mocking tool like dotMock, teams can simulate specific, regulated data flows and third-party service behaviors. This allows for testing compliance controls in isolation, ensuring that test results precisely reflect the component's adherence to standards like HIPAA or GDPR, without interference from external systems.

How to Implement for Maximum Impact

To effectively leverage automation for risk and compliance, integrate these practices into your testing strategy:

• Maintain Immutable Logs: Ensure your test execution environment automatically captures and stores detailed, tamper-proof logs for every test run, including timestamps, inputs, and outcomes.
• Generate Compliance Reports: Configure your automation framework to produce reports formatted specifically for audits, automatically populating fields required by standards like ISO 27001 or SOC 2.
• Automate Security Scans: Integrate static and dynamic security scanning tools into your CI/CD pipeline to continuously check for vulnerabilities and enforce security policies.
• Implement Version Control for Tests: Treat your test scripts as code by using version control systems like Git. This provides a full history of changes to your validation logic, which is critical for auditability.

8. Enhanced Collaboration Between Development and QA Teams

One of the most transformative automation testing advantages is its ability to break down traditional silos between development and QA teams. When testing is automated, quality becomes a shared responsibility encoded in the same codebase. Developers and QA engineers work with the same test scripts, review acceptance criteria together, and collaborate on a unified set of quality metrics.

This shared ownership fosters a "one team" culture focused on delivering a stable product. For example, Atlassian champions this approach by integrating test ownership across all engineering teams, ensuring developers actively contribute to the test suite. This collaborative model eliminates the classic "throw it over the wall" mentality and leads to more robust, reliable software.

Fostering a Shared Culture of Quality

A key barrier to collaboration is when teams operate with different tools, processes, and goals. Automated testing creates a common ground where developers and QA can speak the same language-the language of code-based tests. This shared context is essential for building a proactive, rather than reactive, approach to quality assurance.

When test logic is visible to everyone, it removes ambiguity from requirements. Developers can write code with a clear understanding of the acceptance criteria, and QA can provide faster, more precise feedback directly within the development workflow.

How to Implement for Maximum Impact

To effectively use automation for better collaboration, focus on integrating processes and tools that encourage shared ownership:

• Implement Pair Testing: Have developers and QA engineers work together to write and review automated tests. This practice combines development expertise with a quality-focused mindset.
• Use Pull Requests for Test Code: Treat test code with the same rigor as production code. Require pull requests and peer reviews for any changes to the test suite.
• Establish Joint Quality Goals: Create shared dashboards with metrics like test coverage, pass/fail rates, and bug counts that both teams are responsible for improving.
• Cross-Train Team Members: Encourage developers to learn more about testing methodologies and QA engineers to deepen their coding skills, creating more versatile team members.

9. Support for Complex Testing Scenarios and Environments

Another key automation testing advantage is the ability to handle complex and intricate test scenarios that are often too cumbersome or error-prone for manual execution. Automated scripts can consistently simulate complex user workflows, edge cases, and data-driven tests across countless configurations, ensuring deep validation that manual efforts simply cannot match. This capability is essential for applications with sophisticated logic or those requiring validation across a wide matrix of environments.

For example, a global e-commerce platform can automate the entire purchase flow, testing it with hundreds of different product combinations, discount codes, and payment methods across various regions. Similarly, Salesforce famously tests its platform across more than 2,000 browser and operating system combinations, a feat impossible to achieve with manual testing.

Simplifying Complexity with Service Virtualization

Testing complex end-to-end scenarios often gets blocked by dependencies on third-party services like payment gateways or shipping APIs, which may have rate limits or be unavailable in test environments. This is where service virtualization becomes a powerful enabler.

By using a tool like dotMock, teams can create virtualized services that mimic the behavior of real third-party APIs. This allows for the reliable and repeatable testing of complex workflows, such as payment failures or shipping API timeouts, without relying on the actual external systems.

How to Implement for Maximum Impact

To effectively manage complex scenarios with automation, implement these strategic steps:

• Adopt the Page Object Model (POM): For UI automation, use the POM design pattern to create a reusable and maintainable object repository for web elements. This isolates test logic from UI changes.
• Create Test Data Factories: Build dedicated classes or functions to generate the complex and varied test data needed for different scenarios, making tests cleaner and easier to manage.
• Layer Your Tests: Separate your test suite into distinct layers: unit, API, and UI. This ensures that you test logic at the most appropriate and efficient level, reducing flaky end-to-end tests.
• Leverage Cross-Browser Testing Platforms: Use cloud services like BrowserStack or Sauce Labs to execute your automated tests across a vast grid of browsers, devices, and operating systems without maintaining the infrastructure yourself.

10. Increased Developer Confidence and Code Quality

One of the most impactful automation testing advantages is the psychological safety it provides to developers. A comprehensive, reliable automated test suite acts as a safety net, giving developers the confidence to refactor, optimize, and enhance code without the constant fear of introducing regressions. This confidence is a direct catalyst for continuous improvement and innovation.

When developers trust their tests, they are more willing to tackle technical debt, improve architectural designs, and experiment with performance optimizations. This freedom to modify and improve the codebase leads to higher overall quality, as seen in large-scale projects at Google and Facebook, where robust testing infrastructures enable thousands of code changes daily while maintaining stability.

Building Trust with Reliable Test Data

A common reason developers lose confidence in tests is flaky or inconsistent behavior caused by unreliable test environments or dependencies. If a test fails due to an unavailable third-party API rather than a genuine code issue, it erodes trust in the entire test suite and slows down development.

API mocking tools like dotMock solve this by providing stable, predictable, and fully controllable API endpoints. By simulating various API responses, including edge cases and error states, developers can ensure their tests are deterministic, validating code logic in complete isolation from external factors.

How to Implement for Maximum Impact

To leverage automation for better code quality and developer confidence, focus on these actionable steps:

• Establish Code Coverage Goals: Aim for a practical code coverage target, typically 70-80%, to ensure critical logic is tested. Use tools like SonarQube to monitor this metric continuously.
• Integrate Pre-Commit Hooks: Configure pre-commit hooks to run the full regression suite before any code is committed. This catches issues locally, providing immediate feedback and preventing broken builds.
• Implement Mutation Testing: Go beyond code coverage by using mutation testing to assess the quality of your tests. This practice introduces small faults into your code to see if your tests can detect them.
• Track Defect Escape Rate: Monitor the number of bugs that make it to production. A decreasing defect escape rate is a strong indicator that your automated test suite is effectively improving code quality.

10-Point Comparison: Automation Testing Advantages

Title	🔄 Implementation Complexity	⚡ Resource Requirements	📊 Expected Outcomes	⭐ Ideal Use Cases	💡 Key Advantages / Tips
Increased Test Coverage and Speed	High initial setup; moderate maintenance	Parallel/cloud infra, automation frameworks, skilled engineers	Vastly higher coverage and faster cycles; quicker regression detection	Large apps, multi-browser/device products, CI pipelines	Start with high-value tests; parallelize and use cloud
Cost Reduction Over Time	Moderate–high upfront investment; long-term upkeep	Licensing, infrastructure, automation engineers, training	Decreasing cost-per-test and improved ROI after 6–12 months	Long-lived products with frequent regressions	Calculate TCO; prefer OSS tools and upskill existing staff
Enhanced Accuracy and Consistency	Moderate — requires careful test design	Assertion libraries, reporting, test data management	Deterministic, repeatable results; fewer human errors	Compliance-sensitive and data-validation systems	Use descriptive assertions and baseline image comparisons
Faster Feedback and Early Bug Detection	Moderate — needs robust CI/CD integration	CI servers, fast test suites, developer engagement	Immediate feedback on commits; earlier, cheaper bug fixes	Rapid-release teams and PR-driven workflows	Integrate with CI; keep core suites fast (<10 min)
Improved Test Documentation and Traceability	Moderate — disciplined naming and mapping required	BDD frameworks, test management tools, VCS	Living documentation; traceability between requirements and tests	Regulated projects and teams onboarding new members	Use BDD/Gherkin, map tests to requirements, generate reports
Scalability and Support for CI/CD	High — orchestration, environment provisioning	Cloud infra, containers, orchestration (K8s), sharding tools	Elastic testing at scale; supports high-frequency deployments	Microservices, organizations with many daily deployments	Containerize tests, use orchestration and cloud testing platforms
Better Risk Management and Compliance	Moderate–high — audit controls and reporting needed	Immutable logs, RBAC, compliance experts, reporting tools	Auditable evidence for regulators; reduced compliance risk	Healthcare, finance, pharma, regulated industries	Maintain immutable logs, RBAC, and compliance-focused reports
Enhanced Collaboration Between Dev and QA	Low–moderate — primarily cultural and process change	Shared repos, CI access, training, joint tools	Shared ownership of quality; faster issue resolution	Agile/DevOps teams wanting to reduce silos	Pair testing, review test code via PRs, cross-train teams
Support for Complex Testing Scenarios and Environments	High — complex scripts, data and sync management	Advanced automation tools, test data factories, extensive infra	Validates large workflows, cross-OS/device compatibility, load testing	Enterprise systems with many configurations and load needs	Use POM, separate test layers, leverage BrowserStack/SauceLabs
Increased Developer Confidence and Code Quality	Moderate — requires comprehensive, maintained suites	Test frameworks, quality tools (SonarQube), CI integration	Safer refactoring, improved maintainability, lower technical debt	Teams practicing TDD/continuous refactoring	Track coverage (70–80%), use mutation testing, run pre-commit checks

Unlocking Your Team's Full Potential with Automation

The journey through the core automation testing advantages reveals a clear and compelling narrative: moving beyond manual processes is no longer an optional upgrade, but a foundational pillar for modern software development. We've explored how automation dramatically accelerates testing cycles, expands test coverage to previously unreachable corners of your application, and provides a level of accuracy and consistency that human effort alone cannot sustain. From the immediate ROI seen in reduced manual labor to the long-term gains in developer confidence and code quality, the benefits compound to create a more resilient, efficient, and innovative engineering ecosystem.

However, realizing these advantages requires more than just writing scripts. It demands a strategic approach to building a reliable and predictable testing infrastructure. The true power of automation is unlocked when teams can execute complex test suites on demand, without being hindered by external dependencies, flaky third-party APIs, or unpredictable network conditions. This is where the synergy between a smart automation strategy and powerful tooling becomes critical.

From Theory to Practical Implementation

The transition from understanding the benefits to actually experiencing them hinges on actionable steps. To truly leverage the advantages discussed, your team must focus on creating an environment where tests can run independently and reliably. This means addressing the common bottlenecks that derail even the most well-designed automation frameworks.

Here are the key takeaways to transform your testing strategy:

• Embrace Early and Continuous Feedback: The ability to detect bugs moments after code is committed is arguably the single greatest advantage of automation. Integrating automated tests into your CI/CD pipeline ensures this feedback loop is as short as possible, preventing minor issues from escalating into major production incidents.
• Target High-Value Scenarios: Don't try to automate everything at once. Prioritize automating repetitive, high-risk, and business-critical functionalities. This ensures you see a tangible return on investment quickly and builds momentum for broader adoption.
• Decouple Your Dependencies: One of the most significant hurdles to consistent test execution is reliance on external services. Simulating these dependencies allows you to test edge cases, failure modes, and complex user journeys with precision, ensuring your application is robust enough to handle real-world chaos.

By focusing on these principles, you move beyond simply automating repetitive tasks. You begin building a culture of quality, where developers and QA engineers collaborate effectively, supported by a system that provides fast, trustworthy, and comprehensive feedback. The ultimate goal is not just to find bugs faster, but to empower your team to build better, more reliable software with confidence and speed. The advantages of automation testing are not just about technical metrics; they are about unlocking your team's full potential to innovate and deliver exceptional user experiences.

---

Ready to eliminate testing bottlenecks and supercharge your automation efforts? Discover how dotMock can help you create stable, isolated testing environments to fully realize all the automation testing advantages discussed. Explore our features and start building more resilient applications today at dotMock.