Challenge

The client was experiencing rapid growth, conducting over 200,000 industrial inspection flights, but their QA processes weren’t scaling effectively with their expansion. Key challenges included:

• Fragmented testing processes across different projects
• Development team handling test automation independently
• Disconnected automation efforts
• Lack of standardized documentation
• Insufficient QA resources to support growth

Solutions

Our team conducted a comprehensive QA audit, identifying bottlenecks and gaps in their processes. We introduced a detailed test strategy, standardized workflows, and improved onboarding plans. 

• Analyzed existing QA documentation and processes
• Identified gaps and bottlenecks in current workflows
• Created detailed improvement recommendations
• Assessed team scaling requirements
• Developed detailed onboarding documentation
• Established clear roles and responsibilities

Our team recommended aligning automation testing with manual efforts and offered a metrics framework to track progress and ensure scalability.

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

Following the client’s request, we formed a development team that analyzed the business requirements for the project. The team prepared the documentation necessary for project launch, including a software requirements specification, project management plan, and work breakdown structure. As a software development methodology for the project, we chose Agile.

The tech stack we chose for the development of the solution included Angular for the frontend and .NET, MySQL, and C# for the backend. We used Microsoft Azure as the cloud computing service for the platform and Azure Blob Storage for efficient data management.

In the course of development, the solution has grown from a simple combination of .NET and Angular 2 to a multi-server solution with the latest tech updates and a distributed database, integrated with the existing ecosystem’s user account and analytics systems that feature their own libraries and permission control. In addition, we developed a clever workaround that allows Angular to be more friendly to search engines. 

The workaround is that the main content related to pages that can be indexed by the search engine is not provided by Angular itself but by the server when visiting individual URLs. That is, for a user visiting a specific page, the content is generated by Angular. And if we are dealing with a search bot that goes to specific URLs from the sitemap, the bot receives pre-formed content—the necessary amount of meta-information generated so that everything could be indexed by the search engine. This gives the bot a clear picture of what URL provides what information to users.

Challenge

One of the requested solutions for the client’s ecosystem of digital services was a web tool where architects, engineers, and designers could configure complete wall, floor, ceiling, roof, and other Building Information Modeling component assemblies using generic and manufacturer product data, then download these assemblies for use in their Revit projects. The client already had a legacy solution that wasn’t living up to their customers’ expectations, so our team was tasked with the development of a completely new one from scratch.

Solutions

After a thorough estimation and requirement analysis, we formed a development team and prepared all the necessary documentation for the launch of the 2.0 version of the project. As a software development methodology for the project, we chose Agile.

With consideration of a rich variety of 300,000+ available BIM components that users would have to be able to comfortably research, select, and configure, we needed to make sure that the new version of the content configurator features good usability and utmost performance. To deliver on those requirements, we went with .NET Core and C# for the backend, Angular for the frontend, and Unity as a rendering engine for the tool. As the cloud computing service for the entire platform, we chose Microsoft Azure.

The solution enables users to export product data for each layer in their assemblies or system families. They can customize these assemblies and system families layer by layer or use already assembled system starters from an orderly catalog. 

The tool is integrated with the existing ecosystem’s user account and analytics systems. For customers this means that they can save projects to their profile, keeping all their assemblies in one place, sorted by products, groups, organizations, and so on. They can easily edit, download, and share these projects with their team and organization. For manufacturers, on the other hand, the integrated systems provide the means to efficiently analyze the popularity of their products based on the assemblies the customers have selected/built and saved to their profiles.

Challenge

By the time we received the request from the client, there already was an existing solution with some functionality. However, it was created using outdated technologies, many of which are no longer supported by the developers. So, our team was tasked with developing a web app solution from scratch. The objectives of the project included:

• Get rid of the old unproductive way of retrieving specifications from spreadsheets;
• Speed up the dimensions and cost calculations;
• Discontinue the use of deprecated technologies;
• Ensure rapid and smooth scalability;
• Correctly visualize different shower solutions and specifications despite not having physical access to them;
• Provide customers with an engaging user experience;
• Integrate the client’s existing CRM into the new solution.

After reviewing what was needed, it was decided to split the project into two products:

• A classic configurator that allows customers to use various filters and suggests several existing solutions to choose from;
• A custom configurator that uses even more filters and either suggests one model that perfectly fits the requirements or calculates the cost of a custom solution.

Solutions

From the very beginning, our team has been working on two configurator solutions at the same time, seamlessly switching between them to satisfy the needs of our client more efficiently. This is what we did to fulfill our duties:

• Created the flow to outline the customer journey;
• Created the project architecture to support the flow;
• Gradually added new elements to the architecture to make it meet the client’s business goals;
• Collected all the relevant data, including product specifications and prices, in one source;
• Provided the design for every element of the solution;
• Developed the front-end and back-end parts of the project;
• Used a combination of Git, Jenkins, and Laravel for migrations, ensuring the consistency and stability of the code in all three environments (development, staging, and production);
• Providing live support for the released parts of the project, alongside delivery of new work.

The choice of technologies for the back-end and front-end parts of the project was influenced by the end goals of the project, as well as the current state of the popular programming languages. Specifically, we chose Laravel as our PHP framework and Angular for the front end because both of these technologies make the most sense for enterprise software solutions and are also actively supported by their developers.

The classic configurator was completed first, whereas the custom configurator is a more complex solution and therefore required more time. The work on the custom configurator project was divided into three stages:

• Phase A: Preparing the solution to be used by the client’s sales managers.
• Phase B: Upgrading the solution for use by third-party dealers, which involves disabling certain features and introducing new price calculation functionality.
• Phase C: Releasing the version for the end customers with more opportunities to adjust the functionality — e.g. restrict access to certain areas of the app.

Throughout the whole development process, we also performed continuous software testing within the Agile methodology to ensure the consistency and quality of the solution at every step of the way. With the help of several testing types, including UI/UX, functional, performance, and compatibility testing, we verified the flawless state of each build. We also used smoke and regression testing after the development team introduced changes to the code. Moreover, we used data-driven testing to increase the efficiency of our QA efforts. Finally, we performed user acceptance testing to make sure the software successfully fulfilled its business requirements.

Because the client’s enterprise consists of several smaller entities involved in the development process, the project had a large number of stakeholders who often had differing opinions on what the solution should look and feel like. We overcame this challenge thanks to effective communication and being able to offer a solution that met the needs of all the parties involved.

Solutions

We have provided this SaaS MVP project with 1 business analyst, 1 UX/UI designer, and 2 developers. Later, our client agreed that a decision to strengthen the development team with a skilled business analyst was inspired. She helped to turn generalized plans and high-level processes descriptions into precise and detailed requirements for the system’s functions, clear epics, tasks, and acceptance criteria.

Preparing a SaaS MVP development plan, we have:

• Assessed the client’s technical process and limitations that define a possible tech stack;
• Elicited and formalized business and technical requirements, established projects’ success criteria; 
• Prepared a branched user journey map;
• Assessed the value of each feature, chose the ones that will represent the solutions’ benefits the most, and defined the scale of deployment;
• Ideated subscription plans’ options;

Once the preparation stage was complete, our dedicated development team, in cooperation with the UX/UI designer, has:

• Designed the project’s architecture with all the functional, design and technical components;
• Developed a basic, but scalable, Edu-platform infrastructure;
• Ideated and realized a multi-functional dashboard;
• Ensured transferring from a monolithic to a scalable microservices architecture;
• Realized cloud functionality via Azure;
• Offered and realized the most suitable UX/UI strategy based on the market’s most profitable references and original design solutions;
• Realized skill paths functionality that the users and their supervisor can access;
• Introduced limited but highly representative gamification options (badges, ratings) to boost user’s progress and increase return ratio.

Solutions

The development of the analytics tool started from scratch. To provide the client with an industry-specific analytics solution that would deliver on their business goals best, our team carried out an in-depth research of the client’s business and the latest analytics solutions on the market.

Considering the huge amounts of data the system would have to process, we decided to go with a stack of reliable technologies that feature great scalability and performance. The core backend technologies used on the project are .NET, C#, and MySQL. The front end of the system is built on Angular. We used Microsoft Azure for storage, organization of web services, and to install virtual machines. We combined these and other advanced technologies to ensure stable uninterrupted operation of the service and guarantee that the system will not lose a single piece of statistical data in any event.

The analytics tool is integrated with various third-party plugins, libraries, and APIs to improve performance. The solution features new types of queues and advanced failsafe systems to prevent data loss. One of these failsafe systems involves an API with a separate backup frontend that does not allow the service to go down. Even if the main front end of the solution fails, the APIs will still continue to work, preventing downtime of the service.

The system is integrated with a Salesforce API to enable building product manufacturers to effectively manage the data that would help them promote products and grow their customer base.

To ensure the utmost performance of the system, the incoming data, as it is processed, is aggregated into appropriate tables. For each required type of analytical data, be it page views, visits, average time on site, bounce rate, or downloads, the system creates a separate table with aggregated data. This is done so that these millions of records are not stored in one huge table. Although such a table is also maintained as an archive, so that this data can be verified.

The solution also features a comprehensive user account system with access permissions functionality where the manufacturer’s admins can manage access to analytical data for different members of the company’s team on the platform.

Solutions

The client’s team had no experience in Agile development practices when they came to us. And so, the first thing we did was align the vision and scope for the Agile transformation process and set the right mindset to ensure the smoothest transition for the team. Our main goal was to establish effective leadership and set the team on the path of continuous improvement of their self-organization capabilities with minimum friction or delays.

Overseeing the adoption of the Agile method, we rewired the roles and processes on the project through a series of waves to ensure sustained agility. We improved the project’s velocity and adaptability through individualized support and approaches to each team member, their productivity and ability to respond to changes with positivity and efficiency.

Solutions

From the very start, DueFocus was planned to be a one-of-a-kind product, full of all necessary features to make task and time-tracking as easy as possible. To implement this idea into life, we decided to build the software using microservices architecture, where each service is put in a so-called independent block. This choice made the development process consistent and iterative. With the help of microservices, we could add as many functions as we wanted, with solid confidence that previously existing ones wouldn’t be affected.

Golang was the programming language of our choice because of its simple and concise syntax, small amount of runtime errors, concurrency, and fast development speed.

In combination with Golang, microservices architecture made it possible to pack DueFocus with the functionality that allows users to: 

• create, track, and report tasks
• assess personal performance and productivity
• manage invoice payments and Service-Level Agreements
• check the team’s activity in real time (TeamPulse), and much more. 

Our engineers made the product capable of synchronizing with over 30 major task-management systems (Jira, Basecamp, Trello, etc) to allow users to have all their assigned tasks in one place.

Product interface

Our Front-end and Design teams created graphic interface using React JS and Electron frameworks. The choice fell on JavaScript as the main language for web-view dashboard and desktop app interface, because in tandem with Golang it opens a wide range of possibilities. We managed to simply organize the complex functionality and create an enjoyable appearance with the help of the Web Accessibility Standards.

Quality Assurance

With rich functionality as this, we managed to establish the fast performance of DueFocus in both online and offline modes by thorough software testing. Our QA engineers did performance, functional, load, security, and UI/UX testing to make sure the application is flawless. They put a strong focus on the important items to be easily found, thus making usability of DueFocus even better.

Solutions

Our team worked with the Javascript programming language and the Gitlab tool to meet the goals of the project most effectively. We used the best design practices that allowed us to create a much more intuitive user interface. We chose Agile methodology as the most relevant one and used Skype and Odoo as primary communication channels to ensure smooth delivery of the project.