Challenge

The client wanted to strengthen their product offering with AI-driven capabilities that would make everyday work simpler and more efficient for end users. However, reaching this goal required overcoming several obstacles that directly impacted business value.

Key challenges the client’s team faced included:

• Time-consuming reporting — employees had to rely on technical skills or developer-prepared queries to extract insights from company data.
• Inefficient workflows — routine questions about sales, stock, or suppliers took significant time to resolve manually.
• User adoption risks — without a modern, intuitive interface, the solution could struggle to attract new clients and stand out in a competitive market.
• Cost concerns — existing third-party chatbot tools were either too limited or too expensive to be a sustainable option.
• Evolving requirements — the client’s vision was still forming, and many specifications had to be clarified and refined during development.
• Handling unstructured and large documents — standard parsers failed on files over 10 pages, requiring custom development.
• Integrating structured and unstructured data — the chatbot needed to combine insights from synchronized database tables and uploaded documents.
• Performance bottlenecks — ensuring acceptable response times under heavy queries was a recurring challenge.
• Scalability for future clients — the architecture had to support eventual multi-tenant use without extensive rework.

With the desire to move beyond traditional reporting tools and deliver an intelligent, user-friendly experience to their customers, the client turned to us to bring the chatbot idea to life.

Solutions

To address the client’s requirements, our team designed and delivered a modular AI-powered chatbot that could be seamlessly integrated into their inventory and sales management platform. The solution was built with scalability, cost-efficiency, and ease of use in mind, combining Google Cloud services, a modern frontend, and intelligent data handling.

Modular architecture

The system was structured as a set of independent yet interconnected modules, which ensured flexibility, easy scaling, and simplified future enhancements:

• Data ingestion and parsing — a secure upload flow with short-lived links allowы users to import files safely. A custom parser was developed to handle large documents exceeding standard model limits, enabling the chatbot to process certificates, reports, and images efficiently.
• Structured data synchronization — dedicated modules synchronized sales, inventory, and supplier tables from the client’s database with BigQuery, ensuring the chatbot always worked with up-to-date records.
• Vectorization and retrieval — documents and table data were embedded and stored in BigQuery’s vector index. Similarity search (cosine and Euclidean distance) was used to retrieve the most relevant context for each query.
• LLM-powered query processing — Vertex AI with Gemini models (including Gemini 1.5 Flash for fast responses) served as the reasoning engine. Queries were reformulated against the retrieved context, ensuring accurate, domain-specific answers.
• Frontend interface — a web app built with Next.js provided a responsive, browser-based UI. AG Grid was integrated to give users Excel-like capabilities for working with large data tables, supporting import/export and advanced filtering.
• Security and access control — single sign-on enabled users to authenticate via their existing systems. Pre-signed URLs ensured secure file uploads, and role-based access was built into the architecture.
• Scalability and performance — the backend services were deployed on Cloud Run, enabling serverless autoscaling for handling query spikes. Performance improvements included caching frequently asked questions and categorizing documents to optimize search efficiency.

Implementation highlights

• Cost-efficient AI integration — by combining Vertex AI with in-house retrieval, the solution avoided the high per-query costs of third-party chatbots, making the system financially sustainable.
• Future-ready design — the architecture was built with multitenancy in mind, preparing the client to onboard new customers with minimal additional development.
• Developer-friendly environment — unit tests and modular design ensured quick iterations, while the use of widely adopted frameworks like Next.js and AG Grid simplified maintenance and onboarding.
• User-centric interface — the chatbot was embedded directly into the client’s product workflow, allowing users to move seamlessly from their system to the chatbot without switching tools.

By combining these modules, the chatbot delivered a smooth and reliable experience, enabling users to interact with both structured and unstructured data as naturally as asking a colleague.

Challenge

The client’s logistics management platform had been running on an outdated monolithic architecture that no longer met the company’s growing operational demands. Over time, performance degraded, updates became increasingly risky, and integrations with new tools, such as cloud analytics or fleet tracking, were impossible without significant manual work.

The system’s limited scalability also made it difficult to process higher shipment volumes, while inconsistent data synchronization between modules caused billing errors and delayed delivery reporting. The client needed a way to modernize their platform without pausing active logistics operations, ensuring data integrity, compatibility with existing infrastructure, and measurable performance improvements.

Key challenges:

• No clear process for automated testing or continuous deployment
• Outdated .NET framework and monolithic architecture limiting scalability and integrations
• Slow system performance during peak shipment processing periods
• Frequent data inconsistencies between order tracking and billing modules
• Lack of real-time analytics and visibility into operational metrics
• High maintenance costs due to legacy code dependencies
• Limited support for API-based integrations with modern logistics tools
• Manual report generation slowing down decision-making
• Risk of data loss during system updates or server migrations

Solutions

Our goal was to modernize the client’s legacy logistics system without disrupting active freight operations. We started by analyzing the existing monolithic .NET codebase and gradually transitioning it to a microservices architecture hosted on AWS, ensuring stable performance and scalability.

Modernization included rebuilding the core modules for order processing, billing, and route tracking using .NET, Node.js, and PostgreSQL while introducing new APIs for smooth data exchange between systems. A React-based web interface replaced the outdated frontend, giving dispatchers and accountants a faster, more intuitive workspace.

To improve data integrity and reliability, we implemented automated testing through TestRail and Jira, set up CI/CD pipelines, and introduced monitoring tools for proactive maintenance. The project also added real-time analytics dashboards powered by Python, helping managers identify shipment delays, cost overruns, and route inefficiencies instantly.

Implemented solutions:

• Established continuous system monitoring to detect and resolve issues early
• Migrated monolithic architecture to modular, cloud-based microservices on AWS
• Rebuilt core logistics and billing modules using .NET and Node.js for better maintainability
• Developed REST APIs for seamless integration with third-party analytics and tracking tools
• Replaced outdated frontend with a responsive React interface for dispatch and billing teams
• Added automated test coverage and CI/CD pipelines for faster, safer deployments
• Implemented real-time analytics dashboards for shipment status and cost tracking
• Optimized PostgreSQL data structure to improve query speed and reporting accuracy
• Integrated Docker-based containers for isolated, reliable environment management

Challenge

The client’s logistics operations were growing rapidly, but their existing Odoo setup lacked the flexibility to handle real-time coordination between multiple regional warehouses. Dispatchers relied on spreadsheets and manual scheduling, leading to frequent route overlaps, inconsistent delivery times, and limited shipment visibility.

Additionally, the system wasn’t integrated with their warehouse and fleet management tools, making it difficult to track vehicle locations or update delivery statuses automatically. The client needed a modular, scalable solution that could extend Odoo’s capabilities without disrupting day-to-day operations.

Key challenges:

• Growing operational costs caused by manual data entry and poor synchronization between teams
• No unified transportation management system to handle route planning and delivery coordination
• Manual dispatching processes increasing the risk of scheduling conflicts and human error
• Lack of real-time tracking for vehicles and shipments across multiple regions
• Data inconsistencies between Odoo and third-party warehouse management tools
• Limited automation in driver assignment and route optimization
• Insufficient visibility into performance metrics such as delivery times and fleet utilization
• Difficulty scaling logistics operations within the existing Odoo framework
• Outdated workflows that slowed down decision-making and response to delivery changes

Solutions

To address the client’s growing logistics complexity, our team designed and implemented a custom Odoo module fully integrated into their existing ERP and warehouse management systems. The goal was to extend Odoo’s functionality without overhauling the client’s infrastructure while introducing automation and real-time data flow across all logistics processes.

We developed a transportation management component in Odoo using Python, PostgreSQL, and REST APIs for secure communication with external tools. The React frontend provided dispatchers with an intuitive interface for route visualization, vehicle status monitoring, and driver assignment. The backend included Node.js microservices hosted on AWS to ensure performance stability, scalability, and continuous availability.

Implemented solutions:

• Enhanced data security and access control across logistics modules using role-based permissions
• Designed a transportation management module within Odoo for automated route creation and driver scheduling
• Integrated real-time vehicle tracking via REST APIs connecting Odoo with the client’s fleet tracking system
• Built a React-based dashboard displaying live delivery progress and route optimization insights
• Automated status synchronization between Odoo and warehouse management systems to eliminate manual data entry
• Implemented microservices on AWS for scalable processing of delivery and route data
• Added analytics tools for monitoring delivery times, route efficiency, and fleet utilization
• Set up continuous testing and deployment pipelines to ensure reliability during future system updates

Challenge

Despite being live for several years, the client’s mobile apps faced growing QA challenges. A small internal QA team was stretched thin, fragmented processes slowed releases, and insufficient documentation blocked automation. The distributed development environment further complicated collaboration, leading to inefficiencies and an increased risk of critical bugs reaching production.

Key challenges:

• Unstructured release testing lacking transparency and repeatability.
• Minimal internal QA resources balancing support and testing tasks.
• Disconnected workflows across time zones and distributed teams.
• Outdated test documentation limiting test coverage and automation.
• Low visibility into edge-case and payment error scenarios.
• Inconsistent app performance across diverse Android and iOS devices.
• Manual testing bottlenecks restricting QA scalability.

Solutions

We embedded a dedicated team of manual testers who took full ownership of mobile release testing, bringing structure, transparency, and flexibility to QA processes. Our team rebuilt test documentation, aligned distributed teams, and implemented workflows that replaced ad-hoc practices with reliable, repeatable release cycles.

By adjusting our work schedules, we ensured smooth real-time collaboration during critical phases while enabling near-continuous testing coverage across time zones. Proactive participation in process discussions and proposing QA improvements allowed us to contribute beyond routine testing tasks.

Key activities:

• Establishing stable, repeatable release QA workflows.
• Rebuilding and expanding test documentation for automation readiness.
• Thoroughly testing critical payment error scenarios.
• Synchronizing QA efforts across distributed teams.
• Employing time zone differences for near round-the-clock testing.
• Adjusting work hours for real-time collaboration during releases.
• Driving process improvements and QA best practices.
• Scaling QA efforts without expanding in-house resources.

Challenge

When we joined the project, development was nearly complete, but no testing had been done. There was no test strategy, no documentation, and no quality control in place. Our job was to validate the entire system from scratch and ensure that everything, from user uploads to large-screen broadcasts, worked seamlessly across different devices and conditions. Key challenges included testing the platform under simulated live-event conditions, ensuring stable cross-platform communication, handling large video files, and covering different mobile devices and browsers in our testing environment.

Solutions

We began by auditing all three applications and mapping out their interconnections. From there, we built a structured test checklist to guide our QA process. We used TestRTC and Dotcom-Monitor to simulate file uploads of different sizes, video processing, and 100+ users accessing the system at once. Testing was done on both real devices (2 iPhones and 2 Android phones) and cloud-based environments via Sauce Labs to expand device coverage. Our team worked in close coordination with developers through daily syncs and ongoing communication. Originally planned as a one-month project, the client extended the collaboration to six months based on the value we delivered early on.

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.