Because QA shouldn’t be about repetition.
It should be about consistency, innovation, and impact.
Repetitive workflows are common in enterprise applications: logging into portals, filling forms, uploading documents, validating data, and waiting for confirmations. Performed manually, these tasks are not only time-consuming but also prone to errors.
For QA teams, this often meant repeating the same checks across different environments or re-validating minor changes on developer requests, effort that slowed down delivery without truly adding value. By automating these repetitive tasks, the framework not only saves time but also allows QA to focus on higher-impact activities like exploratory testing and quality improvements.
To address this, I built a Java Selenium automation framework that is modular, scalable, and version-controlled via Bitbucket. While the initial use case focused on tender workflows, the framework itself is application-agnostic and can be adapted to streamline any enterprise process with similar challenges.
This blog shares how the framework was designed, the technical challenges overcome, and how the solutions create a strong foundation for smarter, reusable automation across business-critical workflows.
Section 1: Why Automation Was Needed
Enterprise workflows often involve repetitive, multi-step tasks such as:
- Logging into secure portals.
- Entering unique identifiers and references
- Selecting portal types, categories, and configurations
- Uploading critical documents
- Scheduling processes for execution
- Validating confirmation popups and status updates
Manually repeating these steps across multiple configurations is not only time-consuming but also increases the risk of human error and delays overall delivery.
By introducing automation, we achieved:
- Significant time savings in regression testing
- 100% consistency and accuracy across configurations
- Scalability to handle future features and workflows
- Seamless integration with Bitbucket, paving the way for CI/CD pipelines
Section 2: Framework Design
I kept the framework modular, reusable, and scalable, using Java, Selenium, JUnit 5, and Maven.
Here’s the compact structure:
project-qa-automation
│── src/main/java/com/project/automation
│ ├── locators/ # Application locators
│ ├── models/ # Tender configuration model
│ ├── pages/ # Page Objects
│ ├── utils/ # Config, TenderUtils, FilePaths
│
│── src/test/java/com/project/automation
│ ├── BaseTest.java # Driver setup & teardown
│ ├── LoginTest.java # Login test
│ └── ProcessTender.java # End-to-end tender workflow
│
│── pom.xml # Maven dependencies
│── chromedriver.exe # WebDriver binary
This modular design ensures readability, reusability, and scalability, while making onboarding seamless, new team members can quickly understand the structure and start contributing.
Section 3: Key Features Implemented
Unique Identifier Generation
Tender IDs and Ref IDs are generated inside each test iteration, ensuring uniqueness across runs.
This prevents duplication issues and keeps execution conflict-free.
Memory Cleanup for Generated IDs
To maintain a clean runtime environment and avoid memory bloat, all generated Tender IDs are stored in a Set during execution. After the test completes, this Set is cleared, ensuring that no leftover IDs remain in memory. This small but important step improves efficiency and reinforces robust test design.
End-to-End Workflow Automation
The framework automates the full cycle, from login and document uploads to scheduling and confirmation validation.
It supports multiple platforms and process categories (e.g., Public vs. Limited, Works vs. Goods vs. Services), ensuring broad coverage and consistency.
Smart Dynamic Config Selector
One of the most distinctive features of this framework is its ability to adapt at runtime. Instead of hardcoding options, users are presented with a clean multi-select modal (TestConfigSelector.java) that prompts:
“Select Configurations (Use Ctrl + Click for Multiple Selection)”
Implementation of the Smart Config Selector (TestConfigSelector.java) that dynamically builds the runtime configuration modal.
At runtime, the modal allows:
- Selecting one or more configurations dynamically
- Graceful exit if Cancel is clicked (no dangling browsers)
- Eliminating hardcoding for flexibility across workflows
- Making automation accessible even to non-technical members
The interactive configuration modal shown at runtime, allowing users to select one or more options or cancel gracefully.
This feature strikes the perfect balance between automation power and user-driven adaptability.
Error Handling & Recovery
Robust exception handling ensures smooth execution:
- Graceful shutdown if a user cancels config selection
- Driver quits safely on runtime errors, avoiding resource leaks
Scheduling Automation
Integrated with the “Schedule Now” functionality.
The script waits for a “Created Successfully” confirmation before proceeding, ensuring backend processes are triggered reliably.
Bitbucket Integration
The framework is version-controlled with a branch → PR → merge-to-master strategy.
This maintains a clean commit history, proper author/email configuration, and supports smooth team collaboration.
Section 4: Challenges and Solutions
Ensuring Stable Login Flow
During early test runs, the browser sometimes launched to a blank page.
Solution: Explicitly navigating to Config.BASE_URL before login actions, which stabilized execution across environments.
Maintaining Unique Identifiers
Each iteration required a fresh Tender ID and Ref ID.
Solution: Moving ID generation inside the test loop so every run produces unique identifiers without conflicts.
Graceful Execution Control
When users cancelled the configuration modal, sessions remained open.
Solution: Implemented exception handling to shut down the driver cleanly, avoiding dangling browsers and resource leaks.
Scalable Version Control Practices
Early commits in Bitbucket suffered from mismatched authorship and messy history.
Solution: Enforced proper Git user/email configuration and adopted a branch → PR → merge workflow, ensuring collaboration and traceability.
Streamlined Onboarding for New Contributors
New team members were often unsure about “publish vs push” during their first commit.
Solution: Standardized documentation and defined a clear workflow (git push origin branch → Pull Request), making onboarding seamless.
Section 5: Impact
The framework has delivered measurable benefits:
- End-to-End Automation: Processes that once took hours now complete in minutes.
- Multi-Configuration Support: A single run can handle multiple workflows without code duplication.
- Scalable & Reusable Codebase: Built on modular principles, making it easy to extend for new features.
- Reduced Errors, Increased Speed: Consistency across runs eliminates human error while accelerating delivery cycles.
- Seamless Collaboration: Bitbucket integration with branch → PR → merge workflows ensure clean version control and smoother teamwork.
In practice, this means repetitive, error-prone processes have been transformed into fast, reliable, and scalable systems, freeing teams to focus on higher-value work while building a strong foundation for future CI/CD integration.
Section 6: Future Roadmap
This framework is only the starting point. The next phase of evolution focuses on making it smarter, more secure, and fully integrated into the development ecosystem:
- Secure Parameterization – Move sensitive data like credentials and URLs into encrypted config files, strengthening security and flexibility.
- Comparative Statement Validation – Extend automation to validate extracted data and generated comparative statements, ensuring accuracy across end-to-end workflows.
- CI/CD Integration – Seamlessly plug into Jenkins pipelines so that every build trigger automated testing, enabling continuous delivery with confidence.
- AI-Driven Validation – Introduce intelligent checks for document classification and extraction accuracy, making validation adaptive and context-aware.
By combining these capabilities, the framework will mature into a self-sustaining automation ecosystem that not only executes tests but also validates, learns, and scales with the business.
Conclusion
This framework started with a simple goal: eliminate repetitive manual effort. Along the way, we addressed challenges like login stability, dynamic configuration handling, and unique identifier generation, issues common across many enterprise workflows.
The outcome is a scalable automation framework that delivers consistency, reliability, and speed. With Bitbucket integration, structured branching workflows, and a roadmap toward CI/CD and AI-driven validation, it is both future-ready and adaptable.
Although its first use case focused on tender processing, the framework was intentionally designed for reusability, making it applicable to a wide range of complex business processes.
Ultimately, automation is not just about saving time, it’s about creating systems that are robust, scalable, and innovative. This framework is a step toward smarter, faster, and more adaptable enterprise automation.
Ashutosh Sharma
QA Engineer
Ashutosh Sharma is a QA Engineer with over 2 years of experience in manual, automation, and GenAI-based testing. He has worked extensively on building scalable automation frameworks, integrating with version control systems like Bitbucket, and validating AI-driven solutions. Ashutosh specializes in test automation using Java and Selenium, and is passionate about designing solutions that bring efficiency, reliability, and innovation to QA.
