Having analyzed the customer’s IT system architecture and collected employee feedback on its design,
we concluded it could greatly benefit from optimization. The main challenge was creating a unified
system that would support the management of all customer’s brands and adapt to each brand’s business
objectives.
We suggested dividing the system architecture into separate modules or layers, keeping the solution’s
core in Angular for shared functionality and themes, adding microservice modules, and introducing
separate npm packages to introduce unique features for selected brands. For the customer's
end-clients, this would result in faster product development and time-to-market for new products or
services, scalability, speedy adaptation to changing markets, and improved system maintenance and
upgradability. The customer, in turn, would attract more clients and enhance the loyalty of existing
ones.
Itransition created easy-to-follow development recommendations for building the architecture most
fitting for the customer’s needs, goals, and operations:
-
Define clear project goals, requirements, and scope, keeping only the necessary architecture parts
and modules.
-
Use design patterns and best practices in software development to ensure that the architecture is
well-designed and follows industry standards.
-
Create a single point of truth for architecture-related documents, style guides, step-by-step
instructions for bug fixing, etc., and keep architecture design, components, and interface
documentation updated.
- Conduct code reviews and refactoring of the new system if needed to improve code quality.
-
Use automated testing and continuous integration for new code to ensure architecture quality and
reliability, identifying and fixing any issues early in development.
As part of the consulting services, Itransition performed some development activities to demonstrate
how our suggestions work in practice. Itransition implemented npm packages with reusable modules
developed from scratch to extend a selected brand’s functionality. We also introduced new practices to
streamline development, such as implementing CI/CD practices with GitHub Actions. We also implemented
integrations with various payment systems, speeding up sales of end-clients, and structured the
customer’s frontend implementing a reusable application framework.
Additionally, our developers created a new approach for loading sales funnel parameters in end-client
apps to speed it up, reduce errors, and improve app response time, replacing thousands of lines of
configuration code loaded for each request. We also added a server that loads and caches data only for
the brand currently using it. By making sure the system no longer returns the entire configuration for
all brands and sales funnels, we resolved this bottleneck and built a stable system with distributed
requests.
Having reviewed system documentation, monitored code execution flow, and identified potential
dependencies, our team concluded that the system’s legacy code limited business growth and flexibility,
increased maintenance costs and risk of errors, and lowered employee productivity. To modernize the
outdated code, we advised on refactoring some parts of it and rewriting selected modules to ensure smooth
system operation and ease of maintenance. We also recommended the following best practices:
- Gradually write new code for each system component
- Refactor the code to improve its readability, maintainability, and performance
-
Write unit tests for critical functionality to verify that changes don’t introduce new bugs or
regressions, ensure that the code behaves as expected, and reduce the risk of unexpected failures
-
Make incremental changes to the codebase instead of attempting to overhaul it to prevent accidental
issues and make the process more manageable
-
Document changes to streamline future development efforts and make it easier for other developers to
understand the codebase
Our consultants analyzed the customer’s technical stack and highlighted the following improvement
areas:
- The backend written in Java and Node.js suffered from a complicated, unreadable structure
- The frontend written in an outdated version of Angular
- The Ionic UI toolkit deployed inefficiently
The fragmented frontend structure consisting of many separate applications and legacy tech solutions
created limitations for platform improvements and further customer business growth.
To solve this, we suggested:
- Adding Code Node.js frameworks to systematize the backend
-
Optimizing the solution’s sales funnel, customizing packages by adding APIs, and configuring the
Salesforce TouchCR plugin
- Adding new Angular libraries and keeping all tech stack updated
- Rewriting system parts that use Ionic and substituting it with different libraries
Our team suggested that the customer should use the Split-Testing approach of sales funnels on apps with
different content and written using different technologies, such as Angular (SPA), WordPress, and pure
HTML. Test results could be then used to build marketing strategies. Our QA specialists proposed
conducting performance and functionality testing as well as covering all new code with unit tests,
suggesting the following toolset:
-
Jest for unit tests, selected for simplicity and ease of use, fast execution, built-in mocking and test
doubles, and snapshot testing
-
BrowserStack for cross-browser testing, testing on various devices and OS versions, chosen due to its
extensive device and browser library, and AI-powered testing capabilities
-
Postman used for REST API testing, selected for its capabilities for intuitive API development,
efficient API debugging and testing, and team collaboration
To improve productivity and team satisfaction, the customer needed to simplify their project workflows,
clearly define project roles, and establish effective team management.
We suggested Kanban since the customer’s priorities would often change and they almost had no strict
deadlines for new tasks. Within the framework, the product vision would be formed by the key stakeholders
on the customer’s side and the technical director of marketing together with other business departments.
They would also determine the project roadmap and basic high-level requirements and create and prioritize
new feature development tickets for in-house and third-party developers. In the meantime, the customer’s
developer team creates a pool of tickets, prioritizes tasks, and implements them. Developers are
encouraged to hold refinement sessions with the customer, demo new functionality upon completion, and have
quarterly internal retrospectives. PMs and technical leads should also carry out project health checks on
an ongoing basis.
To ensure transparent and fluent collaboration, we suggested creating a knowledge base and developed a
framework that includes a concept library and communication flow to avoid misunderstandings. The knowledge
base contains guidelines for standardizing ticket creation and resolution, step-by-step instructions on
various aspects of project management, team descriptions, team member roles and responsibilities charts,
etc. To make sure all team members are on the same page, our BAs also wrote a common concept library to
describe new ideas and synchronize internal communication. The process map serves as a single point of
truth, updated when teams, tasks, and project flows change. Additionally, the knowledge base is used for
newcomer onboarding.
We analyzed the process of generating new backend and frontend feature improvement ideas and discovered it
suffered from two main issues.
The first one was the uneven load on the client development team that complicated planning. Developers
were overloaded during peak sales periods and holidays, while slower periods left them idle.
Another issue was unclear feature specifications leading to undefined project goals and complicated task
allocation. Also, too many innovative ideas for new feature development from various stakeholders
increased the need to carefully prioritize features approved for development.
We advised the customer on a more efficient new feature development approach based on the best practices
such as WSJF prioritization, a strict protocol for project requirements and clear specifications
gathering, refining and iterating features post-development, and subsequent monitoring, maintenance, and
support. Our team also suggested using strategies such as modular design, clear documentation,
standardized coding practices, automated testing, version control, and feedback loops to develop easily
maintainable new features.
