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

• Complex API structure. The API system was extensive, with numerous endpoints and dynamic data, requiring comprehensive understanding and efficient testing within a tight timeframe.
• Real-time data updates. Ensuring that real-time data updates were accurately reflected on the client side was a significant challenge.
• Billing and user flow. Verifying the functionality of billing plans, including activation, special conditions, payments, deactivation, and overdue payments, added another layer of complexity.
• New features to test. Just before the release, the client was finalizing new features and pop-ups for premium accounts, necessitating thorough UX/UI testing.

Solutions

We assembled a dedicated team for the job: 5 professionals, including 4 manual QA and a part-time Team Lead, all with a deep understanding of API testing and dynamic data environments.

Our collaboration with the development team was crucial. More than just running tests, we actively reviewed requirements, scrutinized test cases, and identified defects.

Our comprehensive testing strategy included:

• Functional testing. We verified that all data was displayed correctly across the client’s sites. We manipulated the database to simulate dynamic data changes and checked real-time updates.
• API testing. We conducted specific API testing, checking the availability and functionality of each endpoint.
• Billing and user flow testing. We tested billing plans and various user scenarios using test accounts.
• UI/UX testing. We focused on the new features and pop-ups for premium accounts, ensuring a smooth and user-friendly experience.

With a solid team and a clear strategy, we managed to cover over 500 test cases. We used tools like Postman for API testing, which helped us identify several serious bugs.

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.).

Solutions

The first part of the challenge — working with an unfamiliar product — was resolved thanks to the existing experience our team members had with the product as a test management solution. As for the second part, the expertise of our Automation QAs helped us manage the existing test cases with maximum efficiency in a limited time period.

To deliver the required scope of testing, we performed functional testing to verify the core functionality of the product, and then we used regression testing to make sure that the recent changes did not have any negative impact on the product. Other types of testing we employed in this project were:

• Acceptance testing
• Security testing
• Performance testing
• Edge case testing

This was also a project where we used both manual and automated testing. We employed automated testing with the help of Selenium to check the consistency and integrity of the test cases created by the previous team working on the project. 

Our team consisted of five QA engineers, including two Automation QAs and a QA Team Lead.

Challenge

Our main challenge was to review and update existing test cases in the scope of this project prior to executing them. We had to review test cases for both bug fixes and smoke verification, check their consistency, and make necessary updates. All of that, including executing those tests and documenting new bugs, had to be done within a short period of time. 

Solutions

Due to the intense project implementation process, the QA activities were attached to the development sprints and strictly planned into limited timeframes. Thanks to the efficient collaboration with the client’s development team and our usage of ready templates for presenting the review results, we’ve managed to complete all necessary activities before the deadline.

Our QA team consisted of: 

• 2 QA engineers
• 1 QA automation engineer
• 1 QA Team Lead

The team effortlessly fit into the client’s operations and performed every single type of testing that was requested from us, including:

• Exploratory testing
• Functional testing
• Smoke testing
• Regression testing
• UI/UX testing
• Confirmation testing
• Cross-browser testing
• Cross-platform testing

The team members would also reach out to the client whenever we had questions or suggestions about the project, and we have always been available in case the client wanted to make additional requests or comments.

Challenge

By the time we joined this project, the client had been working with a team of manual QA engineers for some time. This resulted in over 10,000 test cases, accumulated over several years, being stored in Google Spreadsheets. So this became our first big task on the project — to move the documentation to TestRail for more effective prioritization and maintenance. Other objectives included:

• Validating all 10,000+ test cases to select the most relevant ones
• Analyzing the existing user scenarios
• Choose around 700 test cases for future automation
• Take over smoke and regression testing from the manual QA team

Solutions

From the very beginning, we focused on developing an effective collaboration between our team and the team of manual QA engineers who worked on the project. We regularly consult with them about test cases, testing conditions, and other aspects of QA. Here is what else we did to meet the project objectives:

• Moved 10,000+ test cases to a single format and storage location
• Imported the cases into TestRail, 500 cases at a time
• Created custom fields in TestRail to prepare detailed reports
• Together with the client, selected 700+ cases that needed to be automated
• Selected and prioritized different types of functionality to be tested in the upcoming sprints
• Perform daily smoke tests and regular regression tests
• Created detailed documentation and manuals using Confluence
• Helped the client adjust the workflow and introduce TestRail milestones for maximum efficiency
• Incorporated our work into the Scrum methodology and delivered the results in two-week sprints

Moreover, we used automated testing to help make the work of the manual QA team more efficient and perform more tests in the same amount of time. We chose Java to automate UI testing because we have successfully used it on similar projects multiple times before.

Our team on this project consisted of:

• One Manual QA
• One to two Automation QAs (on different stages of the project)
• QA Team Lead

Solutions

Our team quickly figured out the existing state of QA within the project and saw what could be improved. We started to provide quality assurance and testing services to our customer right away and were always ready to scale the team up to match the growing scope of responsibilities.

Over the course of the project we have engaged in over 15 types of testing including the following: 

• Accessibility Testing (VoiceOver, iOS)
• Sanity Testing
• Smoke Testing
• Compatibility Testing
• Backward Compatibility Testing
• Functional Testing
• Integration Testing
• Localization Testing
• Regression Testing
• User Interface Testing

We chose TestRail to monitor the testing efforts and organize the work of the QA department in the best possible way. We also used Jira to simplify workflow management, complete tasks easily at all stages of the project, and consolidate the efforts of the subteams working on the web, platform, and mobile aspects of the solution.

Moreover, we used testing automation to increase testing coverage and use our manual testing resources wisely. With the help of the Java programming language and Selenium, we automated 1200+ test cases that are run daily.

Our team used Slack to ensure smooth communication with our client. Our methodology framework of choice was Scrum, which helped us achieve a steady release cycle and increase the quality of the deliverables. The QA team has built an effective working relationship with the development team, allowing everyone to stay updated about the progress of the project and necessary improvements.

Solutions

The project was managed using the Scrum framework, which provided for near-instant onboarding of our experienced QA engineers. We quickly got in sync with the workflows within the in-house team and established efficient communication. 

Our team conducted a thorough analysis of the client’s requirements and the provided documentation to establish the objectives, scope, schedule, risks, and best suitable approaches for QA & testing on the project. 

Our manual testing services covered the wireless smart router itself, the Linux firmware on the device, as well as the iOS and Android versions of the client’s mobile application, the backend, and the analytics system they were using.

Types of testing our team carried out:

• Exploratory testing
• Functional testing
• Sanity testing
• UI/UX testing
• Regression testing
• Confirmation testing
• Compatibility testing
• Cross-platform testing
• API testing

In the course of our collaboration with the client, our team of engineers has built a robust QA process for the project’s further development. In addition to providing detailed bug reports, our team created a solid test strategy and presented a detailed analysis of the client’s software development process where we proposed solutions to optimizing it. 

We improved the quality of project documentation and created a user story template for efficient bug tracking, backlog refinement, and prioritization of the necessary fixes. The improvements enabled the product owner and developers to manage their workload more effectively.

Solutions

The subject of our testing efforts is a HIPAA-compliance-certified project, so it was necessary and appropriate for engineers working on the project to understand and comply with HIPAA regulations. Therefore, we made sure to provide the client with QA engineers who possess deep domain knowledge and experience in Healthcare software development and testing.

We provided the project with 2 part-time QA engineers and 1 full-time dedicated QA engineer. The project was using the Scrum framework for project management.

Despite the fact that we operated in different time zones, together with the client’s in-house QA Team Lead, our QA engineers established transparent, efficient communication with the development teams and quickly got in sync with the workflows on the project.

In close collaboration with the in-house project team, our QA engineers:

• established efficient bug tracking and reporting workflows
• created and executed test cases and performed all the necessary QA activities on a daily basis
• created new and updated the existing documentation, including test scenarios, traceability matrices, and bug reports
• automated regression testing using the Selenium IDE
• reorganized the QA process to prepare the project for further test automation
• provided recommendations on documentation and workflow optimization

Solutions

For this pharmacy software development project, we chose Odoo — an open-source suite of ERP and CRM solutions for fulfilling all kinds of business need — together with the client as a technology that fully meets the requirements of the stakeholders. We developed and implemented Odoo customizations, including integrations and data analysis, to create a solution that makes pharmacy work more efficient and simplified. 

Our team used JavaScript for the front-end part of the solution and the Python programming language for the back-end as two leading pharmacy website development technologies. We chose the Scrum methodology and used GitLab to ensure that the project is organized in the most efficient way. Our client received email reports so that they could keep track of the project progress.