Challenge

The client’s product for this project, a test management tool, was designed to be integrated with Jira and other issue tracking applications. After a series of updates, the client needed to make sure that the updated version of the product could be released and retained all of the functionality users had come to expect. Specifically, our scope of tasks included:

• Verifying the existing functionality
• Checking the presence of all UI elements
• Making sure that each UI element delivers the anticipated response
• Testing the compatibility of the solution with different platforms
• Confirming the correct localization of the product in four new languages
• Ensuring proper integration of the solution with third-party tools

The major challenge of this project was working under strict timeline constraints. For example, our team had to create a large number of test cases (200+) from scratch in a limited time. Another challenge was to plan and test all the possible integrations of the product with third-party solutions.

Solutions

Having collaborated with the client on multiple projects in the past, we were able to build effective collaboration from the start within time constraints. We appreciated the availability of comprehensive documentation that allowed us to quickly get the hang of the features that needed to be tested.

We started by enhancing the existing test suite, making sure that every possible feature of the product is covered by our testing efforts. Then we moved on to following our initial test plan. We also paid special attention to all the possible integrations of the product with third-party services to ensure the correct operation of the solution across all potential combinations.

The team for this project consisted of four manual QAs and one part-time QA lead. The types of testing we performed included:

• Smoke testing
• UI/UX testing
• Functional testing
• Confirmation testing
• Cross-browser testing
• Integration testing

Through weekly meetings with the project stakeholders and the development team, we achieved complete transparency and were able to quickly remove any roadblocks and get timely feedback to move forward with the project.

Challenge

Founded over a decade ago, the client’s company went from a small startup to one of the leading businesses in the travel industry. The product is available as a web application that is also compatible with mobile browsers, as well as native mobile apps for iOS and Android. Still, even though the company has been conquering the market for years with their increasingly popular product, there hasn’t been an established quality assurance procedure in place — testing was unsystematic, usually carried out by developers, and a significant amount of bugs were being found by the end users, which is the least desirable outcome for an up-and-coming solution.

Due to the limited attention paid to quality assurance for years since the product launched, and the absence of a comprehensive bug tracking system or project documentation, our team had to not just test the software, but also implement a reporting and documentation system from scratch. Moreover, the company did not follow any schedule for their releases, unveiling updates on a seemingly random basis, which also made the quality assurance process more difficult.

During the years of working on the project, we helped ensure the quality of 30+ versions of the three apps, each containing valuable updates and improvements. Depending on the scope of requirements, we performed the following types of testing:

• Functional testing
• UI/UX testing
• Compatibility testing
• Regression testing
• Localization testing
• Smoke testing
• Confirmation testing
• API testing
• Exploratory testing

It’s also worth noting that our team working on the project has remained the same throughout the entire collaboration, which means they are now ingrained in the development and delivery process and have even helped onboard new team members on the client’s side. Our team for this project included:

• 1 QA Team Lead
• 1 Manual QA

Through regular meetings and effective communication via Slack, our team can quickly react to changes in the application and developer requests, speeding up the release process and making sure the apps are quickly approved by the App Store and Google Play Store.

Solutions

We typically start the work on a testing project with reviewing the documentation and existing test cases, but with no documentation or test cases to review, our team had to establish the testing process with nothing to base it upon. However, that is something we have plenty of experience with. After spending some time investigating the development process and existing bug management practices, we were able to build a thorough process for documenting bugs, communicating with two distributed development teams, and tracking the progress of the discovered issues with the software.

We introduced GitHub as a bug tracking system that could also be easily integrated into the overall development ecosystem used by the client. Before our team came on board of the project, the release schedule was somewhat chaotic, but our efficiency and speed allowed the client to speed up the release process and gain more confidence in the solution. We also built an effective communication procedure with the client’s development team, so there were little to no delays and misunderstandings that could potentially damage the project.

Challenge

The system was rather old and heavy, and every new change introduced by developers caused a bug in the connected functionalities of the solution, making it unusable. We were hired to fix it. Our goal was to ensure that all updates to the code went through, and the product would be stable and reliable for the client’s use. This required meticulous testing of various components within the Windows server desktop solution.

Solutions

To tackle this challenge, we employed a comprehensive QA strategy that involved a range of testing activities, such as:

• Exploratory testing
• Ad hoc testing
• UI testing
• Functional testing
• Confirmation (retesting)
• Regression testing
• Build verification testing (acceptance testing)

Regression and confirmation testing were performed several times during a project to prevent reappearance of bugs after each new update. By executing regression testing as frequently as the code changed, we were able to catch recurring issues early in the development cycle and address them before releasing the updates to the client. 

We also did a bit of automated testing using the Ranorex tool for writing test suites. However, most of the testing was executed manually to ensure thorough coverage and accuracy. The project spanned across MySQL servers and AWS and underwent rigorous testing for almost a year. 

Through the project, we closely collaborated with developers and product managers. This helped us stay on the same page and ensure that any issues that arose during testing were promptly addressed and resolved. The team chose Skype for communication. Other tools we used for collaboration are Jira, where we tracked bugs and TestRail for writing down test cases. 

In general, the composition of the team on our end included six testers and a Team Lead who worked part-time. 

Solutions

We have assembled a dedicated manual and automated testing team led by a Project Manager. Our team expanded from 3 to 20+ members, reflecting the increasing scope and complexity of the project. To ensure fruitful collaboration, we have:

• Seamlessly integrated with the client’s in-house and remote development teams.
• Participated in daily stand-ups and weekly Scrum meetings, aligning with the client’s 2-week sprint schedule.

We have created and over years enhanced Quality Assurance strategy at the intersection of Manual and Automated QA, Cloud infrastructure and new AI features and solutions.

Comprehensive Manual Testing

Surely, we cover all the standard bases, all the classics of manual testing, but with new features popping up and millions of orders pushing the system to its limits, every day brought fresh challenges. Our manual testing team had to be part detective, part daredevil. Here are some of the testing types we covered to keep manual QA bar high:

• Functional. Ensuring all features worked as intended across the platform.
• Ad-hoc. Identifying unexpected issues through exploratory testing.
• Acceptance. Verifying that the software met all acceptance criteria.
• Smoke. Quickly assessing the stability of new builds.
• Regression. Ensuring new changes didn’t negatively impact existing functionality.
• Accessibility. Verifying the platform’s usability for users with disabilities.
• UI/UX. Assessing the user interface for consistency and user-friendliness.
• Cross-platform. Verifying consistent performance across iOS, Android, and web platforms.
• Confirmation. Validating that identified issues were properly resolved.
• End-to-end. Assessing the entire user journey from product selection to order completion.

But we didn’t stop there. Our manual QA team became the architects of testing, creating unified test plans that brought together both manual and automated efforts. The goal was to create a testing ecosystem that would evolve with the platform. We set up TestRail to showcase both manual and automated test results, complete with screenshots and comments when needed. 

Advanced Automated Testing

With millions of customizable products and a constant stream of new features, our testing needs grew exponentially. Manual testing alone couldn’t cover everything without slowing down releases. We needed a way to test more thoroughly, more frequently, and across more devices – all without ballooning our team size. Automation was the clear solution. Here’s how we built our automation strategy to meet these challenges:

• Developed scripts for simultaneous testing on multiple mobile devices.
• Implemented automated consolidation of test results into comprehensive reports.
• Introduced automatic video recordings of failed tests to aid in debugging low-reproducibility issues.
• Continuously expanded the scope of automated tests to cover an increasing portion of the application.
• Сreated a mobile framework from the ground up, integrating CI/CD via Jenkins and implemented a custom device farm.
• Engineered 80 tests for iOS applications with Swift and XCUITest; optimized the CI/CD pipeline, allowing early error detection.
• Cataloged a Pytest API framework with 100+ automated backend tests.
• Set up the mobile web (mobile browsers Safari/Chrome) Appium framework from scratch (with BrowserStack, and lately, transferred to LambdaTest) and achieved 180 e2e test coverage.

By ramping up our automation efforts, we dramatically cut down on regression testing time. This was a game-changer for our manual testers. Freed from repetitive tasks, they could focus on exploratory testing of new features, edge cases, and complex scenarios that machines can’t handle.

Cross-Platform Device Testing

Some clients have the latest iPhones; others use older Android tablets. We needed to ensure our client’s app worked great on all of them. It’s not just about different screen sizes — each device has its own quirks. To address this issue, we have:

• Used over 40 iOS and Android devices, including both flagship and older models.
• Ensured consistent performance across a wide range of hardware configurations.

AI and Machine Learning Integration

Our client took personalization to new heights with AI. They built a smart system that does more than just sort products. This AI helps customers design items, suggesting themes, colors, and layouts. It even recommends how to place photos and add special touches. It’s like having a personal designer built into the app. To ensure this AI-powered personalization worked and delivered real benefits, our team:

• Conducted comprehensive testing of new AI-driven personalization features.
• Provided regular feedback to the development team, contributing to iterative improvements.
• Ensured successful rollout of the AI-enhanced version to 100% of users.

Cloud Migration Support

For a platform handling millions of orders yearly, moving to the cloud is inevitable necessity. But migrating such a vast system, with its mountain of data and complex operations, is like performing heart surgery while the patient runs a marathon. Every piece had to move seamlessly, without disrupting the constant flow of orders.​​

• Assisted in the transition of servers and resources to cloud infrastructure.
• Maintained regular testing duties while supporting the migration process.

Scalability and Performance Testing

• Implemented load testing scenarios to simulate high-volume transaction periods.
• Verified system stability and responsiveness under peak usage conditions.

Continuous Improvement and Adaptation

• Regularly reviewed and updated testing strategies to align with the evolving product.
• Expanded our testing scope to cover newly acquired software products and integrations.

Challenge

The client contacted us when they were finishing working on another update of their product with a request to perform comprehensive testing of the whole solution, test the tickets supplied by the development team, and then perform complete regression testing of all basic functionality, even if it was not affected by the changes in the code.

One of the main challenges of the project was the fact that the solution works with a large variety of databases (including SQL and MongoDB-based ones), which meant that knowledge of the database technology was integral for testing the product correctly.

Moreover, there were over twenty databases deployed on the client’s side, which sometimes posed an additional challenge for us because we couldn’t quickly access those databases in case there were any hiccups in their operation. Our productive cooperation with the client’s team, including the Product Architect, helped us overcome this challenge by establishing a fast response procedure for these situations.

Solutions

Part of the client’s request was to create new test coverage, which meant we had to write new test cases to ensure that. In the duration of the project, our team created 150+ test cases from scratch, as well as worked with the existing ones.

To overcome the challenge of multiple databases and complex technologies required for all-encompassing testing, we selected members of the team who specifically had experience with databases to work on the project.

The types of testing used on this project included:

• Exploratory testing
• Functional testing
• Regression testing
• Smoke testing
• Build verification testing
• Acceptance testing
• Cross-platform testing

To speed up the testing process, increase test coverage, and improve the efficiency of testing, we employed the services of automation testing engineers. They also helped create and test scenarios that relied on the knowledge of software code to be successful.

In an effort to better meet the client’s technical and business needs, we used a dynamic team setup, expanding and downsizing the team as needed. Overall, the team working on the project consisted of:

• 1 QA Lead
• 5 to 8 Manual QAs at different stages of the project
• 2 Automation QAs

Despite the fact that our testing team and the client’s development team were located in different time zones, we managed to make it work by establishing an effective collaboration process with a combination of synchronous (including weekly calls) and asynchronous communication.

Solutions

Engineers from QArea created a solid solution with practically limitless customization capabilities, a friendly, intuitive interface and a whole stack of useful features, like:

Employee management functionality that includes:

• The ability of assigning personal logins to employees;
• Access to data from employee accounts can be limited;
• Employee schedules can be created and productivity can be tracked;
• Employees can be granted access per limited amounts of time like during their scheduled shifts, etc.

iConnnect can be a CRM:

• Limitless amounts of customers can be added to accounts;
• Information about these customers can be noted down and stored;
• Users are empowered to create and place customer-related notes that contain vital information;
• All purchases conducted by customers may be viewed;
• Customer balance is stored 9gift cards, returns, much more).

• Appointment calendar functionality is integrated into the app;
• Report generation functionality is available as well as data extraction possibilities;
• Merchant inventory data is comfortably stored and easily tracked;
• Marketing-centric functionality is considered as well:
  • Discounts are easily created;
  • Discount code and expiration date may be added;
  • Loyalty programs can be offered to faithful clients and all related data will be stored in their profiles;
• Back Office management solutions are available;
• So is booking functionality;
• Much more.

Challenge

We have already realized several projects for this client, and this had to become integrational for a few products we already worked with. It put extra incentive — we wanted to make sure that our client’s customers can use whatever we co-developed before to the fullest. Here is what we had to face in order to achieve it:

Regulatory Compliance in Construction Materials

Construction is a highly regulated field, every material used must meet strict specifications. Professionals involved in construction and repairs need to ensure that all the products are certified accordingly. Any delay in creating submittal packages or problems with confirmation back-and-forth games with regulators mean loss of time and money for real construction or restoration projects.

Efficient Project and Document Management

The traditional process of sourcing documents for each construction material is time-consuming and inefficient. Moreover, professionals often need to manage multiple projects simultaneously, requiring a unified and easy-to-navigate system for document and project management. To get a submittal package right and make all the data in it unified can cost dozens of extra work hours.

Integration and Data Synchronization

A major requirement was the integration of the BIM catalog site with Microsoft Dynamics for real-time data synchronization. This integration was crucial to ensure the catalog’s data accuracy and up-to-dateness, as well as hussle-free database operations for our client.

User Accessibility and Global Reach

Given the global nature of construction projects, it was essential to make the products BIM catalog accessible in different languages (when available) and adaptable to various international standards and certifications. 

Solutions

Our Front- and Back-end engineers developed a comprehensive BIM catalog site that provides detailed information about each construction material. The site includes all necessary certifications and specifications, making it easier for professionals to find and verify the compliance of materials. 

This approach not only streamlines the compliance process but also ensures safety and adherence to industry standards. 

We’ve designed a user-friendly interface allowing users to save various configurations and documents in their profiles, eliminating the need to collect them from scratch each time. The site enables management of multiple projects with an advanced filtration system and thought-out sorting capabilities. 

These features significantly reduce the time and effort required in managing construction projects and related documentation. A user can generate a submittable package consisting of dozens of unified pages for products ranging from glue to brick in minutes. 

Here are some of the key features that make this catalog so efficient:

• Unified product database centralized all relevant certificates and documents for streamlined access;
• Custom package building allows users to select needed certificates on demand instead of combing through everything;
• Multi-format downstream generation enables seamless hand-offs to partners; 
• User cabinet and saved configurations per project reduces redundant setup work;
• Advanced filtering and search simplifies document lookup by type, language, and more. We worked hard on sorting, to make sure no matter how you look for something, should you mention even one characteristic right (name, certificate type, etc.), an in-built search engine gets it right. 
• Optimized algorithms generate full packages in minutes or even seconds instead of hours. It takes just 5-10 seconds to generate a single document or two, and up to 10 minutes to prepare a full submittal package for some grand construction.
• New functionality allows editing already built configurations to alter submissions.
• Multi-lingual support for many products and certifications in catalog supports global construction standardization

Our dedicated Manual QA expert meticulously tested every aspect of the site, from user interface and experience to data integration and synchronization. They conducted thorough tests to ensure compatibility with different web browsers and responsiveness to various screen sizes, crucial for users accessing the site from different devices.

The QA process also involved validating the site’s functionality in terms of document management, project handling, and data filtration. The team performed end-to-end testing of the user journey, ensuring that every feature, from login to document download, worked flawlessly.

By developing an intelligent hub to consolidate, customize, and streamline compliance document preparation, we saved construction firms tremendous manual effort and delays preparing needed submittals.

Challenge

With hundreds of parts and components available, there could be thousands of possible pergola configurations, which was a challenge in itself. In addition, we had to:

• ensure that these modifications looked real, providing users with a vision of how the future construction would look like when installed on the site;
• anticipate and eliminate possible errors that could occur in the configuration process due to the complexity and variety of options. 

Solutions

Through years of partnership, we’ve learned to intuitively understand this client’s needs, often tackling projects, streamlining processes, and addressing pain points with minimal requirements at hand.

When we first started, the team chose Unity to design the interface. However, the decision was soon made to change it in favor of Autodesk. It is a much more user-friendly technology that not only creates more visually appealing designs but also easily combines with Revit, which was chosen as a primary tool for the project. This transition positively impacted the entire project, resulting in more realistic rendering of 3D components and a significantly improved UX. 

Furthermore, we proposed to add a “save and share via link” feature for the configurations built. This addition meant a lot in terms of user engagement and marketing. Moreover, we’ve found storage services that could convert data free of charge and be seamlessly integrated into the configurator. The client approved this solution, and the implementation of this step is scheduled. 

The composition of the team working on this project included:

1 x Front-end developer (Angular)

1 x Back-end developer (.NET), 

2 x Revit & Autodesk Visualizator, 

1 x QA engineer. 

We’ve finished a big scope of work, but our collaboration continues, with more configurations and features to be developed in the upcoming months. 

Challenge

We were entrusted with automating testing the company’s custom NetSuite application used for order management, payment processing, and other operations. 

• Our client used only manual testing without applying optimization techniques or automation;
• We had to turn test cases shortly described in Word documents into a working test automation scripts system;
• Create and run tests for two separate environments;
• Foresee potential crash scenarios and bottlenecks, find and report bugs and critical system blockers.

Solutions

Automation testing diminishes manual intervention and allows for minimizing mistakes as well as speeding up the entire process. To complete our tasks, we have provided this project with two experienced auto QA engineers, who have accomplished the following:

• Created and implemented efficient UI, and end-to-end testing plan;
• Automated 100% of test cases, taking into account NetSuite peculiarities and business logic inherent to the client’s industry;
• Launched daily test runs that allowed us to find bugs and critical blockers almost immediately;
• Implemented CI workflow for more efficient communication, a better rapport with the client’s team, and reliable continuous integration;
• Ensured faster-debugging thanks to extended test coverage;
• Defined critical blockers causing system crashes and offered ways to improve system security.

Tools and Technologies

For this case, we have chosen a combination of tools and technologies for automation testing that allowed us to enhance efficiency and minimize time. 

• Selenium WebDriver: for scalability and robust support across various platforms and operating systems, as well as creating reusable test suits. 

• TestNG: for simplified management of test cases, all the benefits of parallel testing, the possibility of parameterized and dependency tests, as well as clear, “by default” reports. 

• TestRail: for more efficient test management organization and improved organization of testing efforts according to the automation tasks our team has faced in this project.

• Jenkins: to support continuous integration and enable efficient automation process within the scope of our immediate tasks and testing strategy.

Communications

We have entered this challenge following an executive director who was our client in one of the previous automation projects. Communication with a new team was predominently held through him, which had pros and cons. On the one hand, we always had inside reach and solved any issues fast and efficiently. On the other hand, when our trusted liaison quit taking a new position elsewhere, our communication with the client’s team was crippled, and we had to establish new processes hurriedly. 

Thanks to the on-point documentation we have been creating from day one and the seamless workflow our team honed on various other projects, the transition period was brief and didn’t affect our speed or efficiency. 

Impact

Methodology. Our cooperation was first based on the Kanban methodology. It didn’t fully answer the speed and efficiency demands of most of the automation tasks and bug-fix workflow. We have offered to try Scrum workflow, which proved to be more productive and, as to our knowledge, has been used by the client’s manual testing team till now  

TestRail workflow. Our QA implemented and established the TestRail workflow for the entire team. It included all the step-by-step supporting documentation and month-long training instructions for a current manual testing team and specialists that would join the company once our project was done. 

Challenge

In this project, we have faced numerous environments that needed to be checked during the day, two versions of the application, each of which required at least three versions of auto tests. We provided this project with three automation and two manual QAs, who had to work with the QA manager and two manual QAs from the client’s side. The overall number of developers on this project reached 20+, which guaranteed a non-stop flow of updates, new features, and releases that required quality assurance services. Here are some significant tasks we had to tend to initially:

• Establishing QA workflow and developing needed test-related documentation from scratch;
• Support and continuous QA for new features introduced by developers;
• Optimizing workflow with the client’s ticket management system to determine automation candidates;
• Improving internal workflows with multiple simultaneous runs on the Jenkins server;
• Ensuring rational use of the allocated space on the Jenkins server and pre-paid Testrail plan;
• Ensuring fast automation deployment on separate client’s environments.

Solutions

Teaming up with the client’s QA specialists, we have created and implemented product-specific API, performance, regressions, and smoke tests. Here is more about what we have achieved working on this project:

• Implemented integrations between the following pairs: Liquidplanner & Testrail; Jira & Testrail. It allowed better issues’ detecting and tracking the latest status of the tickets.
• Using the mentioned integrations, generated a custom QA daily report for better visibility of QA team activities and depiction of issues that were found during the day;
• Implemented performance testing using k6.io that allowed coverage of the main workflows using API endpoints for four environments;
• Provided analysis of the result/metrics, establishing the maximum number of users a particular environment can support;
• Organized and provided daily support for four environments, using more than 2400 tests in total; 
• Created and implemented tools for fast analysis. Our QA created a custom tool, which collects test results from each environment and groups them by error hash. It allowed to bind all errors during one action easily;
• Optimized tests’ architecture, internal workflows, and custom tools/reports that allowed making analysis much faster and determining where the bug or test needs to be re-run;
• Improved test speed by rewriting tests using API endpoints for the generation of data required by tests. This approach was tried on a bunch of tests, showing a significant reduction in execution time. Now, it is being implemented for all the environments.
• Improved tests’ execution, introducing a new, custom tool for quick start of tests which should be re-run during the workday; 
• Implemented Readable screenshots feature that allowed adding the test’s output to screenshots, reducing time for locating the issue;
• Developed interactive visualization of test coverage—a unique solution that allows us in real-time to see where we don’t have test coverage.

Automation

• Achieved fast automation deployment on separate client’s environments;
• Used Jenkins CI to ensure all runs are running on schedule. After each rebuild of the environment, smoke and the main regression tests are launched;
• To ensure seamless UI automation, used a custom combination of ProtractorJS, Selenium, Jasmine programming languages

Business processes

To enhance internal business processes, we created a tracker for all important indicators:

    – how many users / roles were created 

    – how many files were uploaded

    – how many messages / tags were created, etc.

Now, this data comes from each test during a run and shows QA team, DevOps, Backend developers how many tests can be run in parallel and how many resources should be added to each server, where massive requests trigger server errors (MySQL, Redis, RabbitMQ, etc.).