In the evolving landscape of software quality assurance, JetBrains introduced Aqua as a groundbreaking solution designed specifically for test automation engineers. Released in 2022, JetBrains Aqua is a new standalone IDE that was designed to support test automation, representing the company’s commitment to addressing the unique needs of QA professionals. This comprehensive review explores Aqua’s features, capabilities, and its ultimate place in the testing ecosystem.
The Vision Behind Aqua
QA and test engineering are essential parts of modern software development. At JetBrains, we believe using the right tool matters for every job. Creating a separate tool for automated test development was a natural step for us, as it allows us to cover the needs of multi-role software development teams. Rather than forcing QA engineers to adapt developer-centric IDEs to their workflow, Aqua was built from the ground up with test automation as its primary focus.
The IDE was constructed on the IntelliJ platform, meaning users would find familiar features from other JetBrains products, but with unnecessary elements removed to create an uncluttered environment specifically tailored for QA tasks.
Core Features and Capabilities
Multi-Language Support
Aqua’s language support covers Java, Kotlin, Groovy, Python, JavaScript, TypeScript, HTML, SQL, and stylesheets (CSS, Less, Sass). This polyglot approach ensures that QA engineers working across different technology stacks can maintain a consistent development environment. The IDE provides intelligent coding assistance, including context-aware code completion and automated refactoring capabilities that update references throughout the project when changes are made.
Framework Generator and Project Setup
One of Aqua’s standout features is its comprehensive project generator. JetBrains Aqua offers framework generators including Maven Archetype, Selenium, Kotlin Multiplatform, Compose Multiplatform, HTML, React, Express, Angular CLI, Vue.js, and Vite. When creating a new project, users can select their preferred build tool (Maven or Gradle), test runner (JUnit or TestNG), JDK version, and programming language, streamlining the initial setup process significantly.
When opening a new project to test the framework generator in Kotlin-Selenium, Aqua also allows choosing useful reporting dependencies like Allure as well as a very useful dependency for automation like Selenide. This integration eliminates the manual configuration that typically consumes valuable time at the start of new test automation projects.
Web Inspector: A Game-Changing Tool
Perhaps the most innovative feature Aqua introduced was its embedded Web Inspector. The embedded Web Inspector allows you to view web applications in Aqua and capture page elements required for automated tests. Aqua generates a unique CSS or XPath locator for the selected element on the web page and helps add it to the source code.
The Web Inspector’s functionality extends beyond simple element identification. If there is more than one locator that uniquely identifies the same element, Web Inspector will suggest all possibilities. While maintaining tests, Aqua helps you verify existing locators. Just validate your CSS selector or XPath with Web Inspector and check whether the locator identified the element you want.
Example Workflow:
- Open your web application within the Aqua Web Inspector
- Select the desired element on the page
- The IDE generates appropriate CSS or XPath locators
- Choose your preferred locator from multiple suggestions
- Add the locator directly to your Page Object with proper naming conventions
The fact that through the inspector we can automatically copy the selector to the PageObject of our choice could create a link between said selectors in our PO and the web inspector. This integration represents significant potential for future enhancements, such as detecting broken selectors by comparing code values with Web Inspector findings.
Rich Selenium and UI Testing Support
Aqua provides rich support for the Selenium API and Selenide, offering code insight for the CSS, XPath, and JavaScript fragments used in the Selenium API and many other libraries for UI testing. When following the Page Object pattern, the IDE helps you create and maintain new page object files from the New File menu and respects the selected page object pattern when adding locators.
This native understanding of testing patterns means that Aqua doesn’t just provide syntax highlighting—it actively assists in maintaining consistent architectural patterns throughout your test suite.
HTTP Client for API Testing
Modern test automation often requires API validation alongside UI testing. IntelliJ Aqua also comes with its own HTTP client for API testing. The built-in client enables testers to create and edit HTTP requests, complete with code completion, syntax highlighting, and refactoring support. Integration with OpenAPI specifications facilitates API discovery and documentation within the same environment used for test development.
API Testing Example:
GET https://api.example.com/users/123
Content-Type: application/json
###
POST https://api.example.com/users
Content-Type: application/json
{
"name": "Test User",
"email": "test@example.com"
}
Database Management Integration
Aqua allows you to integrate database management into the IDE for scripting, low-level assertions, and a host of other operations. The range of integrations is quite wide today and it is useful if the tests work directly with a DB or if we do some data management of any kind, for example, prepare a previous dataset before launching our tests.
The IDE supports major database systems including Oracle, SQL Server, PostgreSQL, and MySQL, allowing testers to connect to live databases, execute queries, validate results, export data, and manage schemas through a visual interface—all without leaving the development environment.
Docker Support
Containerization has become essential in modern testing environments. With IntelliJ Aqua, we have access to our Docker containers, being able to run them, debug them, download them and build images or run multi-container applications. This functionality proves particularly valuable when executing tests against specific configurations, such as production-like environments without direct production access.
Test Management System Integration
Aqua can connect to external TMS systems, such as TestRail, making the tests more accessible from the IDE. It supports browsing test suites and case hierarchies, as well as navigation for TMS items. The IDE also introduced an experimental “Local TMS” approach, storing test data as markdown files within the project for better version control and integration with automated tests.
Practical Implementation
Getting Started
When launching Aqua, users are greeted with the familiar JetBrains authentication interface, supporting JetBrains accounts, Google, GitHub, and other authentication services. The generated files belong to a class that does nothing more than contain the page selectors (MainPage.kt) and a test class that prepares a basic configuration for the tests and the methods necessary for the test (MainPageTest.kt).
The generated architecture follows a simple but scalable Page Object Model pattern, providing an excellent foundation that teams can adapt to their specific needs.
Code Quality and Testing Support
Aqua incorporates JetBrains’ renowned code analysis capabilities. The IDE continuously checks code for quality and validity issues, suggesting context actions for resolution. Aqua supports JUnit, TestNG, Pytest, Jest, Mocha, and other popular frameworks for writing, running, and debugging unit tests.
Strengths and Limitations
Notable Advantages
- Unified Environment: Consolidates multiple testing tools into a single IDE
- Framework Support: Extensive support for popular testing frameworks and libraries
- Project Generation: Rapid project setup with sensible defaults
- Native Testing Patterns: Deep understanding of Page Object and other testing patterns
- Familiar Interface: Leverages the well-established IntelliJ platform
Identified Limitations
During the preview phase, several limitations became apparent:
No support for mobile test automation and no support for Cypress or Playwright (although these two are expected to come later in development). The generator misses the option of providing Selenium alongside Cucumber, which is a big loss if the user wants to automate in a non-JS language. Difficult to use right now on a daily basis, as the versions released can crash quite often.
The tool is still somewhat green in terms of performance and stability. As I write this article the IDE has crashed from time to time after clicking on some options in the inspector.
The Aqua Sunset
Despite its innovative approach and powerful feature set, Aqua’s journey came to an unexpected conclusion. Aqua has not reached the level of adoption we initially envisioned. After evaluating market trends and user feedback, we have decided to consolidate its capabilities into the broader JetBrains ecosystem through the Test Automation plugin.
The final release of Aqua is version 2024.3. There will be no further regular updates (except vulnerability fixes), and support will be gradually phased out. However, this doesn’t mean the end of Aqua’s capabilities in the JetBrains ecosystem.
Migration Path
Although Aqua as a standalone product is being retired, all of its core capabilities will remain available through the Test Automation plugin, which is available in IntelliJ IDEA Ultimate, PyCharm, and WebStorm (including for non-commercial license users), as well as other JetBrains IDEs.
For existing Aqua users, JetBrains provided a generous transition:
- Current licenses were automatically upgraded to All Products Pack licenses
- Users with licenses purchased before April 22, 2025 can continue using Aqua
- Non-commercial license holders received options for WebStorm licenses or All Products Pack discounts
Target Audience and Use Cases
Aqua was ideally suited for:
- QA Automation Engineers: Professionals focusing primarily on test automation rather than application development
- Teams Using Multiple Testing Technologies: Organizations requiring database management, API testing, and UI automation in a single environment
- Docker-Based Testing Environments: Teams leveraging containerization for test execution
- Organizations Following Page Object Pattern: Projects implementing structured test automation architectures
In my opinion, IntelliJ Aqua can be a good complement to the daily work of QA Automation, especially for those who already use technologies such as Docker or Database management for their tests.
Conclusion
What We’ve Learned
Through this comprehensive review of IntelliJ Aqua, we’ve explored a bold experiment in creating a dedicated IDE for test automation professionals. The key takeaways include:
- Specialized Tools Have Value: Aqua demonstrated that QA engineers have unique needs distinct from software developers, validating the concept of specialized testing environments.
- Feature Integration Matters: The integration of Web Inspector, database management, Docker support, and API testing capabilities within a single environment showcased how consolidation can improve workflow efficiency.
- Innovation Requires Adoption: Despite innovative features like the Web Inspector and TMS integration, Aqua’s market adoption didn’t meet expectations, highlighting that technical excellence alone doesn’t guarantee success.
- Evolution Over Isolation: The transition to the Test Automation plugin demonstrates that specialized functionality can survive and thrive within broader ecosystems, potentially reaching more users while maintaining focused capabilities.
- The Testing Landscape Is Changing: Aqua’s journey reflects the dynamic nature of the testing profession, where tools must continuously adapt to evolving practices, frameworks, and organizational needs.
While Aqua as a standalone product has concluded its journey, its legacy lives on through the Test Automation plugin available across JetBrains’ IDE portfolio. For QA engineers seeking the specialized features Aqua pioneered, these capabilities remain accessible within the broader, more established JetBrains ecosystem—proving that sometimes integration serves the community better than isolation, even for specialized disciplines.
The experiment that was Aqua ultimately taught the industry valuable lessons about specialization, user adoption, and the importance of meeting practitioners where they already work, rather than requiring them to adopt entirely new tools for specific tasks.
