<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[True Engineering - Medium]]></title>
        <description><![CDATA[Technology Innovation Lab - Medium]]></description>
        <link>https://medium.com/trueengineering?source=rss----af628329a24d---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>True Engineering - Medium</title>
            <link>https://medium.com/trueengineering?source=rss----af628329a24d---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 11:18:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/trueengineering" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How We Have Automated Mobile Apps Submission to Stores]]></title>
            <link>https://medium.com/trueengineering/how-we-have-automated-mobile-apps-submission-to-stores-1a1244292df1?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/1a1244292df1</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Wed, 12 Jan 2022 10:02:41 GMT</pubDate>
            <atom:updated>2022-01-12T10:02:41.509Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Time-to-market (speed of delivery of features to users) is one of the key indicators by which we assess development efficiency. Today, we will talk about how we have accelerated and improved processes in mobile development, where we have come a long way from manually installing apps for testing to almost fully automated submission of releases for testing and publication.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ix0GvvRHPcC19Zl4" /></figure><p>Why is a small time-to-market figure a competitive advantage for a company that develops its own products? It’s simple: the faster you deliver updates to users, the faster you get feedback, the faster you can fix bugs, test features and refine them. The customers on their end manage the product better if they get results from the team quickly. They can also make adjustments quickly, with the flexibility to fully manage the final product.</p><p>In complex processes that bring together analysts, designers, developers, QA engineers, optimizing each step makes a significant contribution to the final result. So, when we started to develop our mobile app development business. We started looking for opportunities to automate every step as much as possible to save people from manual work and to secure against mistakes.</p><p>Below is a description of what that journey looked like, what results we came up with and what benefits we achieved.</p><h3>Step 1: automation</h3><p>At the start more than 10 years ago, developers were building versions manually, testers would come to them to get builds, connect a smartphone to a computer, download the build for themselves, and so on. The process was not very fast and, most importantly, it was hindered by the human factor as the testers had to ping the team, and the developers were distracted from their tasks in order to hand over the product to them.</p><p>We started by implementing automation through Jenkins. Teams were given sets of scripts to prepare builds and submit them to our own App Store. On this site, each project automatically had a page where the latest version of the app was published. From here, testers would take the release for review.</p><p>This is the first step that separated the development and testing processes: we no longer had to physically connect the phone to the computer. We even made QR code generation so that people don’t have to type in addresses and tap the links on their smartphone screen with their fingers, just point their camera at the computer screen, scan the code, and get an application.</p><p>It was already very convenient, but there was one problem as the service supported only one version. If it was necessary to bring up a previous version to test an update, difficulties began to arise. And when our applications grew to thousands of users, it became necessary to have several retrospective versions of the application at hand. The point is that users don’t update their software in an orderly fashion, and if older versions start to fail, we need to be able to reproduce the problem.</p><h3>Step 2: version control</h3><p>At that time, several products for managing application versions appeared. We researched the market and chose the Beta service. It allowed adding groups of users (developers, testers), assigning different rights to them, configuring what notifications will be received by certain users. Most importantly, we were able to upload and manage version chains.</p><p>We determined what versions we need and how we should work with the environments. Some things we found out by trial and error, for example, how many debug-versions we need for a particular environment, so that we do not get confused and quickly identify the sources of problems in applications. We started with our own debug-versions for each environment and eventually came to one version, switching between environments through a separate screen, if necessary.</p><p>A few years later, we switched to the App Distribution service, which runs on the Firebase platform. This solution is now used by our mobile teams. In Firebase, the application usually has three versions: (1) dev — the environment is deployed to us, (2) stage — where the customer accepts the work, (3) release build, which is automatically deployed to the published app version.</p><p>App Distribution allows you to download the build and automatically send notifications to responsible employees. Those in charge, like testers and developers, can connect right away, and if their smartphone is connected to our infrastructure, they get the update on their device right away.</p><p>At the same time, the toolkit for automating builds and publishing evolved. The next milestone was the transition from Jenkins. For a while, we experimented with Gitlab CI/CD, but eventually the company management <a href="https://trueengineering.co/article/how-we-built-project-management-system-based-azure-devops">has decided </a>to move to Azure DevOps (TFS).</p><h3>Step 3: TFS pipelines</h3><p>We now have a set of events in our processes that automatically run the pipelining in TFS to perform certain tasks. For example, after merge, the source is pumped out to the developer branch, build takes place, artifacts are sent to Firebase, and a version card is automatically created.</p><p>TFS prepares automatic builds with a description of what was done for each build. As we have already told earlier, release notes are automatically pulled from the performed tasks. The tester can immediately see which build is up to date and what has changed in it and can download it and test it.</p><p>This eliminates possible delays due to the fact that someone has downloaded something wrong, signed something incorrectly, causing a confusion that will ultimately interfere with the release.</p><h3>Result: fast and transparent CI/CD processes</h3><p>It saves the tester’s time to get the build, so they don’t have to bother the team to get a version delivered. All participants in the process know at any given time what they need, as TFS tags automatically change the status of the build, and all changes can be conveniently tracked. In fact, when each participant has finished their section, they can forget about the task; automation further controls the process.</p><p>Now we have developed an approach to building versions for all possible environments. The processes are debugged and automated. The next big goal is the <a href="https://trueengineering.co/article/how-were-implementing-trunk-based-developmenthttps://trueengineering.ru/ru/cases/TBD-experience">transition to TBD</a>. We still have to figure it out. For example, there are questions about how to test code if it is constantly filled in the wizard, how to work with hotfixes…</p><p>We are now practicing these approaches on one of the largest projects, where TBD is being built from the very beginning. In a few months, the product will be delivered, and by that time we will have a complete picture of the processes. We will share our experience.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a1244292df1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/how-we-have-automated-mobile-apps-submission-to-stores-1a1244292df1">How We Have Automated Mobile Apps Submission to Stores</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Code Storage Management Affects IT Product Competitiveness]]></title>
            <link>https://medium.com/trueengineering/how-code-storage-management-affects-it-product-competitiveness-44814f8147b5?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/44814f8147b5</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Wed, 03 Nov 2021 06:01:13 GMT</pubDate>
            <atom:updated>2021-11-03T06:01:13.326Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>The choice of repository affects the updates delivery speed. A poor model can severely hinder the market penetration of new features and stall development processes. In this article, we will explain difference between different kinds of repositories and why this is more about a team management than a technology itself.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cW_2pOH4ELQkcT8k" /></figure><p>Without going deeper into the details and thinking about hybrid options, let’s say storage is divided into two types:</p><ul><li>A mono repository is a single repository for all the product components. It includes libraries, business logic modules, interface, some service utilities, etc.</li><li>Multi-repositories are distributed repositories for product components. In this case, the services are small and built individually, with small code checks.</li></ul><p>Both approaches work well and reflect essentially two philosophies that can be used to design IT projects. Read on to find out more about how they affect team processes, which style we follow and why.</p><h3>How a mono repository works</h3><p>It is important to note that a mono repository does not mean a single-tiered software app at all. Some different microservices may well coexist in such a repository, which will use common code or libraries.</p><p>This approach is used by many global companies, e.g., Google, <a href="https://habr.com/ru/company/yandex/blog/469021/">Yandex</a>, and Microsoft. The latter have <a href="https://devblogs.microsoft.com/appcenter/how-mono-repo-and-one-infra-help-us-deliver-a-better-developer-experience/">abandoned </a>distributed repositories in favor of a single one several years ago.</p><p><strong>Advantages of a mono repository are as follows:</strong></p><ul><li>It is easier to manage dependencies in the code. Developers can create common components to be used by different product modules. This is helpful in controlling the amount of deployment packages.</li><li>It is easier to identify errors and perform refactoring. Everything is quite obvious here as it is much faster to clean up one storage than ten.</li><li>Team members interact more with each other. In a single repository, a common approach develops faster, and there is more motivation to collaborate and work together on the product.</li><li>It is easier to immerse new developers into the project. The more repositories there are, the harder it is to understand the overall picture and the dependency between the product modules.</li></ul><p>But there is a flipside, and they become more noticeable as the product grows. In a major project, the team will encounter performance issues, the repository becomes too slow to fetch or clone, standard git commands can take several seconds, and file searches become noticeably slower.</p><p>But the most unpleasant thing is the difficulties with CI. When multiple people work in the same repository, the delivery processes will be severely slowed down due to constant builds. In the most severe cases — to a complete halt, as shown by the author of <a href="https://habr.com/ru/post/436264/">one of the posts </a>on the subject:</p><blockquote>Imagine your project’s build time is 30 minutes. There are 100 developers working on the project, each of them fluffs 1 commit per day. And here is the question: ‘How many hours in a day does it take for the CI server [which only lets you merge changes into the master after they have been applied to the most recent commit] to merge changes from all developers? The correct answer is 50.</blockquote><p>As a result, improperly configured CI will noticeably increase the development cost, increase Time-to-Market, and as a consequence, worsen the competitive position of the product. The company will overpay for unnecessary work, as the system will restore all services at each click. The multi repository helps solve these problems.</p><h3>How the multi repository works</h3><p>As we said before, this approach assumes that each microservice resides in its own separate repository. The small size of the services, separate versioning, and quick code checks save the team from performance issues during delivery.</p><p>Among the proponents of this approach are Amazon and <a href="https://netflixtechblog.com/towards-true-continuous-integration-distributed-repositories-and-dependencies-2a2e3108c051">Netflix</a>. Here at True Engineering, we also have been moving in this direction for some time now, and here’s why.</p><p>The benefits of a multi repository:</p><ul><li>High performance in large projects. This is the main argument in favor of multi repositories, so we will repeat it again. Amazon and Netflix, as mentioned above, use distributed approach to release updates more often, get feedback from users faster and strengthen their market position as a result.</li><li>It’s easier to test releases. You don’t have to check every time to make sure everything works properly with other software. If something breaks, changes are very easy to roll back.</li><li>It is easier to manage the life cycles of microservices. For the same reason, the fewer internal dependencies, the easier it is to pull out one component and add another.</li><li>Ability to easily reuse components in other systems.</li></ul><p>At True Engineering, there are no separate teams within a single product. We aim to build a Trunk Based Development model that assumes shared ownership of the code. In distributed repositories, shared logic is harder to isolate. With the purpose to allow developers to reuse code, we isolate their components into separate libraries that can be plugged into any service in any repository.</p><p>It is worth noting that even in the case of a mono repository, it is not possible to simply link code and reuse classes from one microservice in another. This leads to the fact that these services will need to be built and updated at the same time, so the pluggable library approach saves team effort here as well.</p><p>Shared libraries need to be managed carefully so as not to break public APIs that are already in use across multiple services. We solve this problem with library versioning and contract tests.</p><p>In addition, you get more versions of different components, and they need to be managed globally somehow. It becomes harder for developers to understand the overall picture, code checks may be less efficient than we want them to be. Several components can get into a release independently of each other, and we need to understand which tasks end up in the build. This is where Azure DevOps and our platform customizations over it come to our rescue. Our CI/CD is versioning our applications and in related tasks puts a tag with the name of the environment on which the change is deployed for that task, also indicating the version of the corresponding service when needed.</p><p>Bat the same time, we have to note that these difficulties can be overcome if teams have common processes, share common experiences and have a development platform. For example, we at True Engineering have been actively introducing <a href="https://trueengineering.co/article/microservice-pattern-why-do-you-need-it-and-how-implement-it-development-processes">microservice templates </a>over the last year, and the multi repositories are helping us to industrialize them. The template has already included settings for the pipelines, build and deployment parameters, so all the developer has to do is develop the business logic and off you go.</p><p>However, mono repository performance problems will not be overcome by the right processes. When the product grows to a certain level, it will physically stop building quickly.</p><h3>Our experience and findings</h3><p>Ultimately, the choice of approach depends on what is more important to the team — ease of development or ease of delivery and use.</p><p>Developers may find it more difficult to work with multiple repositories, but businesses will benefit greatly from this approach. The low Time-to-Market, constant releases, and even <a href="https://trueengineering.co/article/how-true-engineering-manage-alerts-product-monitoring">advanced system monitoring </a>that will show if performance has gone down after a release all add value to the product for the end user.</p><p>That is why we opt for multi repositories in our projects, and reduce possible difficulties in teams by common standards and platform processes. These are already mentioned common libraries, templates of microservices and projects, tests, etc.</p><p>However, currently there are only a few products among our solutions in separate repositories. This is partly due to the fact that many of our systems were created almost 10 years ago, when the world had very different ideas about development. Nowadays, releases are built with scripts while at that time the concept of continuous development was only being formed and the discussion about DevOps methodology had begun. After all, Docker appeared in 2013, and Kubernetes did in 2014.</p><p>Besides, let us remind you that with small projects it is really more convenient for the team to use a mono repository. And separating repositories in an already running product is a costly task.</p><p>That is why we are implementing a multi-approach in new products — there were about five of them this year, each with a dozen microservices. These projects take full advantage of <a href="https://trueengineering.co/article/hands-experience-creating-development-platform">our platform</a>, and even independent teams work on the same processes that are often automated.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44814f8147b5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/how-code-storage-management-affects-it-product-competitiveness-44814f8147b5">How Code Storage Management Affects IT Product Competitiveness</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hands-on Experience: Creating a Development Platform]]></title>
            <link>https://medium.com/trueengineering/hands-on-experience-creating-a-development-platform-9e99060368f8?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/9e99060368f8</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Thu, 09 Sep 2021 08:26:27 GMT</pubDate>
            <atom:updated>2021-09-09T08:26:27.667Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Since 2020, we have been building an IT platform approach to product development. We have formed a set of technologies that should be replicated by all our teams, so that across the company we can centrally manage the quality of development. Today, we share our expertise of how these technologies are being tested in our new projects.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/0*a3y8coS2cPIRSzdq" /></figure><p>To begin with, here is a brief discussion of the technologies behind the platform. We have described many of them in detail in our previous articles:</p><ul><li><a href="https://trueengineering.co/article/how-logging-libraries-help-our-teams-support-products">Standard logging libraries</a>: featuring a typical set of functions that do not change from product to product, including composition of logs, requirements for capturing and tracing data, etc.</li><li><a href="https://trueengineering.co/article/microservice-pattern-why-do-you-need-it-and-how-implement-it-development-processes">Microservice templates</a>: allowing teams to create new microservices within just a few minutes.</li><li><a href="https://trueengineering.co/article/how-we-unified-project-template-our-teams">Project templates in Azure DevOps</a>: creating a holistic view of project management: both at the top level, where managers plan product development, and at the bottom level, where developers execute tasks and release products to the customer.</li><li><a href="https://trueengineering.co/article/quality-gates-how-we-integrate-automatic-code-checks-our-processes">Quality Gates</a>: automatic quality checks that set thresholds for moving a product down the development pipeline.</li><li><a href="https://trueengineering.co/article/how-feature-flags-help-build-software-factory">Feature Flags</a>: featuring toggles in the code and providing the business with leverage to control product features.</li><li><a href="https://trueengineering.ru/ru/cases/c4-notation">The C4 architectural notation</a>: a convenient model for comprehensive description of software architectures.</li></ul><p>At the time of the transition to a common platform, different teams used these technologies in different ways: some were already used to working with feature flags, some were looking closely at them, templates were just being created, etc. Over the past few months, one way or another, all of our teams have experienced these practices in real life scenarios. And here are the results we came up with.</p><h3><strong>Logging libraries</strong></h3><p>These libraries provide teams with the same understanding of logging requirements. They combine a certain set of functional characteristics that do not change from product to product, such as the composition of logs, data tracing tools and standards, etc.</p><p>The capabilities of the standard libraries have been appreciated by all teams, and they are now used in all new projects. If necessary, individual technical details are finalized on the fly. Most importantly, the products include all the logging tools we need right from the start, making it easier for teams to support and monitor in the future.</p><h3>Microservice templates</h3><p>The point here is that teams can create new microservices in just a couple of minutes, according to the same architecture standards.</p><p>These funds are also successfully used in all new products. Over the last quarter, three of our teams saved 60–80 hours in total at the start of projects.</p><p>Upon having some practice, it became clear that it is difficult to prepare such a template in advance. But after the launch, it is quite a lively idea to build a template and industrialize the creation of microservices. On top of that, we have found tremendous value not only in the templates as such, but also in the pre-prepared TFS pipelines. In the future, we plan to template other areas of work as well, such as the frontend and individual, repetitive code sections.</p><h3>Project templates</h3><p>Another technology that is designed to relieve teams of routine, and the company as a whole, to provide a one-for-all approach to project management.</p><p>These templates are successfully used by all teams. As a result, there is less TFS routine, the task hierarchy is the same for everyone, as well as the principle of branches naming. The next plan is to figure out the size of the tasks, so that tasks and PBI include approximately the same number of hours, but that’s just a small thing.</p><h3>Quality Gates</h3><p>We are talking about static code analysis, for which we use SonarQube. Now backend services in our new projects are tested everywhere, unit-test coverage is 80–100%.</p><p>Currently, there are 121 repositories under SonarQube verification, of which 81 are actively developing (there are commits from the last six months). As we can see from the results of the checks, the complexity of the support, security and reliability of the code in general is at a good level, up to SonarQube standards.</p><p>Most importantly, this approach has proven beneficial as there have already been several cases where SonarQube found errors for the team. We continue to develop. In particular, soon we will check backend and mobile application libraries’ licenses in this way. In the future, we are thinking about using it for information security and the frontend.</p><h3>Objectives for the near future</h3><p>One of the hottest trends for us right now is the introduction of Trunk-Based Development and feature flags. An important innovation of new projects is that teams create separate repositories for each microservice. This greatly simplifies separate deployment. The positive effect is emphasized when combined with microservices templates, which offloads developers’ hands.</p><p>Autotest coverage, without which it will be difficult for teams to deliver features to users quickly, is a part of this area, where the key goal for the near future is to cover critical feature sets with autotests.</p><p>Finally, our teams are increasingly using C4 architectural notation. And although no one is working based on a manual yet. We have already gained the main advantage of this approach, namely, automatic creation of documentation during development.</p><p>Teams have eliminated the need to maintain diagrams in separate knowledge bases, and architecture data is updated automatically. Regardless of which tools the teams use (some now work with PlantUML, others with MermaidJS).</p><p>At the moment, we are already seeing positive results from working with all the technologies on which we opted to build our platform last year. Most importantly, there has been a positive response from the teams themselves, who are really finding it easier to work with. This means an incentive to spread this experience further.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e99060368f8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/hands-on-experience-creating-a-development-platform-9e99060368f8">Hands-on Experience: Creating a Development Platform</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How We Manage Design Systems]]></title>
            <link>https://medium.com/trueengineering/how-we-manage-design-systems-49bfd1c2838a?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/49bfd1c2838a</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Thu, 02 Sep 2021 10:05:23 GMT</pubDate>
            <atom:updated>2021-09-02T10:05:23.292Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>A design system is a set of components, rules, and tools without which it is near-impossible to develop large and complex products. These approaches allow designers to develop an interface without having to create basic components from scratch, and it becomes easier for developers to accept ready-made layouts for work.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*peKmz70FsJ3Lhyax" /></figure><p>The main reason to systematize design in a large product is to ensure consistency of the solution, so that from release to release all elements of the design retain the same look and feel. You don’t have to start working on the interface with drawing buttons as in a mature system, all the basic elements are ready, and you can immediately address the business tasks.</p><p>The team should have a single source of knowledge about all design components and the right ideas about how they work. Otherwise, neighboring sections will have different logics of working with documents, and the “Next” links will start to move from corner to corner. This is not only untidy, but also greatly affects the usability as the user needs to relearn over and over how to work with the interface.</p><p>Without a design system, it will be difficult for the team to reach a steady supply of releases as too much will have to be re-created, refined and coordinated. Design will become a bottle-neck for the entire team, which will have a noticeable impact on Time-to-Market.</p><p>In other words, a professional product team will shape its design system sooner rather than later. The developments of many large companies are also publicly available.</p><h3>Where the design system starts</h3><p>The first step to conscious design management is to create a UI kit. This is the library in which designers contain the key design elements of a project. It contains everything from the smallest icons to entire groups of objects that are used together in the UI (such as massive shapes or a screen for capturing documents through the application).</p><p>This library formulates uniform rules for designers, developers, and any other participants working on the portal, helping the team to improve the UX using preconfigured styles as a constructor. In addition to the components themselves, the UI kit also includes rules for their use: how buttons behave in different scenarios, how drop-down menus interact with control panels, how to display notifications, messages, action confirmations, and what they should contain.</p><p>If you don’t have a UI kit, then with each new iteration of the project and with each new designer there will be more icons, buttons, and text styles. UI kit helps to synchronize designers and reduce component chaos on large projects. And in the long run, it helps designers stick to the rules they’ve formulated themselves.</p><p>For example, here is part of the UI kit of one of our products. It contains colors with assigned variables to make it easier to use them in code, lists of fonts, paragraph indents, buttons, icons with all types of hovering.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OkCfBWc14sdcaL7L.png" /></figure><h3>Interaction with the development team</h3><p>The UI kit itself will already save designers a lot of unnecessary tasks. A single source of truth emerges to properly reuse components. But the team needs a mechanism to communicate the design to the developers. Not only technically, but also in words, designers explain why certain elements are needed, what the logic behind them is and what purpose it serves from the user’s point of view. This is not a one-way road as competent frontend developers can often offer a successful solution.</p><p>The design process at True Engineering takes place in three basic steps:</p><ol><li>Designers draw preliminary layouts, make up a chain of screens according to the script.</li><li>Layouts are discussed with analysts, UX editors, customer representatives, and other stakeholders.</li><li>When all comments and observations are taken into account, the layouts are handed over for development.</li></ol><p>Over the past few years, we have developed a set of tools that we use at every step. Prototypes are drawn in Sketch, screens and scenarios are conveniently discussed with analysts in Miro, and developers are used to employing Zeplin.</p><p>Each of these services does an excellent job, but there is an obvious problem: materials have to be updated in three spaces in parallel. Not all of these resources are suitable for collaborative work. And lately we have been faced with the necessity of having several people working together on a file and changing something there more and more often. More and more our products reach the stage of development when specialists from different departments of the client’s enterprise get involved in the work on them, and several designers, UX specialists, and editors may take part in the process inside our company. At the same time, we need up-to-date data at any given moment, and there is neither the possibility nor the desire to transfer layouts between platforms.</p><p>So, we wanted to unite the production sites so that it would be convenient for everyone to work together on layouts. Recently, we have been moving to Figma, a platform that combines almost everything we need to work together on layouts. Here we can work intensively on materials, make multiple edits at the same time, send mock-ups to the clients and receive comments from them. And support entire design systems.</p><h3>Conclusion</h3><p>Our portfolio includes products with a long history, so before we move to a new platform, we need to figure out how to transfer all the accumulated material to it. Otherwise, a single data source and centralized updating of elements, which is the main advantage of the design system, is lost.</p><p>So now we are “packing our bags” to launch all new projects in Figma.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49bfd1c2838a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/how-we-manage-design-systems-49bfd1c2838a">How We Manage Design Systems</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[S7 Mystery Passenger — Creating a data flow for constant customer care]]></title>
            <link>https://medium.com/trueengineering/s7-mystery-passenger-creating-a-data-flow-for-constant-customer-care-c3b0c020faa8?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/c3b0c020faa8</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Tue, 31 Aug 2021 09:24:57 GMT</pubDate>
            <atom:updated>2021-08-31T09:24:57.378Z</atom:updated>
            <content:encoded><![CDATA[<h3>S7 Mystery Passenger — Creating a data flow for constant customer care</h3><p><strong>The Mystery Passenger service is created by True Engineering for S7, Russia’s largest private airline. It allows the collection and processing of feedback from passengers, exchanging discounts and bonus miles for important business information. At the time of its launch, it was the first solution of its kind on the Russian airline market.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mGVv-wTqSO5bbEqJ" /></figure><p>S7 Airlines collects feedback from passengers from all possible sources. This includes information processed by the call center, questionnaires that passengers fill out after the flight, and feedback in social media. Mystery Passenger is an excellent addition to these sources, as it helps collect useful nuances in service from different points throughout the customer’s journey and promptly carry out measures to improve the passenger experience. The built-in reporting system allows users to quickly detect service violations and work them out with airline services. When necessary, user can quickly contact the author of the report to clarify the details.</p><p>The idea of this service is to involve the passenger in monitoring the service. People like the idea of being a mystery shopper and are interested in similar projects in other areas. And S7, for its part, can quickly receive passenger feedback and evaluations at every stage of the entire Customer Journey.</p><p>The key advantage of Mystery Passenger is that passengers leave feedback on service in real time and with maximum detail, attaching photos and videos. As a result, the company receives detailed information, and negative feedback from service in a particular area (for example, a broken armrest in the cabin) does not affect evaluations at other stages.</p><p>After the implementation of the project, the airline has improved the quality of feedback in areas where rare feedback was available before. For example, in the summer of 2021, S7 offered passengers a new service for transporting pets in the neighboring seat. It used to take up to a month to collect feedback on new services, after which the airline’s specialists made the first results about how much passengers liked it and what bottlenecks they themselves highlighted. Now there is a mystery passenger on almost every flight, who provides immediate feedback. As S7 employees themselves say, they have become better at understanding their customers.</p><p>In some cases, negative comments can be worked out the very next day after the receipt of the review. The passenger arrives, takes rest after the flight, and finds a letter in the mailbox from the airline with a solution to the reported situation.</p><p>Anyone can download the app from the App Store or Google Play and confirm their identity by name and reservation number. The passenger will then be able to assess the level of service at each stage of the trip: from arrival at the airport and check-in to saying goodbye to the crew at the exit from the plane.</p><p>The app tracks the travel process independently: when the booking starts, the passenger is offered to evaluate the work of the staff at the airport counters, and when boarding, questions about the service on board appear on the screen, and so on. The service supports different types of questions: open, closed Yes/No and questions with fixed choice of suggested answers. Passengers can attach photos and videos to their questionnaires.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*V1h448bhY7vbXDuM.png" /></figure><p>As a reward, users receive bonuses in the form of S7 Priority miles or a promo code for a discount on tickets. As a result, the airline passengers feel personally involved in improving the service and receive financial incentive for this work.</p><p>On the S7 side, the solution is integrated with the airline’s internal analytics systems. Employees can view the entire flow of incoming reviews along with attached photos and videos, unload selections by configurable parameters, and transfer information for further claims handling. Thanks to end-to-end analysis tools, it is possible to fall from a general report on a flight to an individual report and vice versa, get all the information related to an individual photo, video file or review.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CW7cE5zwUVXnIq6M.png" /></figure><p>A typical work scenario: assess the overall picture for the reporting period, see the flights with low ratings, download and study the feedback, and generate claims to pass them on to the responsible employees.</p><p>Even in pandemic conditions, when the number of flights has drastically decreased, the Mystery Passenger remains a reliable source of data on service on its flights for the airline. Each month, S7 receives up to 10,000 completed reports through Mystery Passenger.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c3b0c020faa8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/s7-mystery-passenger-creating-a-data-flow-for-constant-customer-care-c3b0c020faa8">S7 Mystery Passenger — Creating a data flow for constant customer care</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How we use Google Identity Platform to secure work projects]]></title>
            <link>https://medium.com/trueengineering/how-we-use-google-identity-platform-to-secure-work-projects-117a82144326?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/117a82144326</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Thu, 26 Aug 2021 10:23:33 GMT</pubDate>
            <atom:updated>2021-08-26T10:23:33.026Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Some time ago, we decided to rebuild the management of access to mobile teams’ workspace. We researched the market and found that the free Google Cloud Platform could effectively compete with paid solutions. In this article, we share our experiences and provide instructions on how to connect.</strong></p><p>Our mobile app developers are running their projects in Firebase, a platform by Google that integrates monitoring tools, user analytics in apps, and other useful tools. There is an alert system that sends notifications to the email if something in the app starts going wrong.</p><p>Previously, employees joined projects in Firebase through their own Google accounts. The same way the workspace was accessed by customer representatives including analysts, PMs, etc. This scheme created serious security risks as if the personal account was compromised, attackers would have a direct path to our products. There were also no centralized control tools to disconnect an employee who quit the team or left the company, let alone users from outside the company.</p><p>In addition, Firebase users with basic roles had excessive permissions, for example, “editor” and “viewer” could move into the project management console.</p><h3><strong>How we took control over the situation</strong></h3><p>So, we needed an authentication system that would provide login without private addresses, having an administrator console to control all project participants. We also needed a way to give the users the minimum rights they needed. We did not have to go far and the solution was a cloud platform run by Google (Google Cloud Platform, GCP).</p><p>Now we have a corporate account, which we synchronized with Active Directory. Team members receive invitations to join the project via email and authenticate with their True Engineering login. Synchronization with Active Directory is done through Google Identity Platform (GIP), which also provides Single Sign-On.</p><p>Since the credentials come from our AD, Firebase automatically complies with our own security rules, such as password management policy and user hierarchy. Participants do not need to be added manually as they are automatically pulled into the GIP admin console from AD.</p><p>As to access rights management, the platform is very powerful: there are about 5 thousand roles provided. The user can configure access for any purpose.</p><h3>Main security features of Google Identity Platform</h3><ul><li>The admin panel has an entire list of users with access to working projects, you can assign and unassign access rights with a couple of clicks. There are tools to control IP addresses with the ability to send an alert if a user logs in from an unusual location.</li><li>The SSO system keeps track of the list of applications where users log in to their work address. Of course, these are applications that are connected to work projects and privacy is maintained. Unnecessary or insecure applications can be forcibly deactivated via the admin panel or by assigning group policies to the applications.</li><li>You can see how many documents an authorized user has uploaded to Google Drive, and how many files he or she has made available. Again, for privacy reasons, the content of the files is not disclosed. But if a company has strict rules about using the cloud, this feature could be very useful. For example, True Engineering prohibits developers from sending work files to public clouds.</li><li>There is basic but not bad vulnerability analytics (<a href="https://cloud.google.com/security-command-center/docs/concepts-security-health-analytics-overview">Security Health Analytics</a>). It helps to automatically detect configuration problems, unprotected ports, and more serious threats. If a product has the ability to execute arbitrary code, intercept data, or gain unauthorized rights, the Security Command Centre will show the vulnerable asset and suggest how to eliminate a particular threat.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/0*3qpB9mH2MVQ0lSSG.png" /></figure><ul><li>Remote employee device management tools allow user to lock a stolen or lost smartphone. In addition, there are alerts about hacked gadgets: in Android it checks for root access, and for iOS jailbreak is monitored. For us, this feature is not very useful, as our mobile developers use exactly such devices, but in general, the information is more useful.</li></ul><h3>How to set up Google Identity Platform</h3><p>1) Go to <a href="https://cloud.google.com/">Google Cloud Console.</a><br>2) Log in with your GoogleID.<br>3) In the control panel on the left side, find IAM &amp; Admin position, and click on the second item:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/0*qd43CkAlOjb8KzC2.png" /></figure><p>4) Clicking will open a window to go to the checklist.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/637/0*4JeyVFjZvsqjjEP8.png" /></figure><p>5) Follow the step-by-step instructions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/637/0*oaCoWAvwAVO7rWPy.png" /></figure><p>The super administrator can do absolutely anything. In particular, only a super administrator can restore an account.</p><p>Use the super administrator role to create “regular” administrators who will perform work tasks, hide the super administrator credentials in a safety locker.</p><p>It is very important to carefully build the resource hierarchy. Do everything step by step, do not skip anything. Note that permissions are inherited: if something is missing, a user with minimal permissions can gain maximum access.</p><p>At the end, be sure to double-check everything. For example, make sure that a user without “Owner” rights can’t invite anyone to the project or go to the Google Cloud console. At the Firebase level, a regular user should not have Add member and Advanced permission setting buttons active.</p><p>Short checklist:</p><ul><li>You must have a Super Administrator</li><li>Administrator at the organizational level</li><li>Administrators at the resource level (units, folders, projects)</li><li>One user can have multiple admin rights.</li></ul><p>The Firebase administrator has maximum rights only in Firebase:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*-8nZ8bcFBhQMWCUl.png" /></figure><p>The organization administrator has maximum rights at the organization level. Only Project Mover can create, delete and migrate projects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/617/0*Si78mycjsyprE0ig.png" /></figure><p>See <a href="https://support.google.com/cloudidentity/answer/7319251?hl=ru">Google Help </a>for more information.</p><h3>Conclusion</h3><p>As we said above, from our point of view, the solutions by Google are almost as good as many of the paid products currently offered on the market. All of the features we’ve described here are available in the free version of the Google Cloud Platform, which includes access for 50 employees. We have about 40 specialists in our Mobile Apps Development Department, so these features are quite enough for us.</p><p>Besides, if you need to increase the quota, you can send a request to Google support, and they are likely to provide you with what you need. For example, in our work we use the BigQuery tools, also from the Google portfolio. They are paid, and the billing is calculated by the volume of requests sent. Using these systems may well be an argument for expanding the free GCP quota.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=117a82144326" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/how-we-use-google-identity-platform-to-secure-work-projects-117a82144326">How we use Google Identity Platform to secure work projects</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Machine Learning: How We Use It in Tech Support]]></title>
            <link>https://medium.com/trueengineering/machine-learning-how-we-use-it-in-tech-support-27cc0b02b716?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/27cc0b02b716</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Wed, 11 Aug 2021 10:08:17 GMT</pubDate>
            <atom:updated>2021-08-11T10:08:16.876Z</atom:updated>
            <content:encoded><![CDATA[<h3>For about a year now, the support team of one of our high-loaded instruments has been using an ML-system of our own development, the Problem Detection Platform (PDP). This service can analyze logs and automatically classify errors. As a result, the support team does not get a bunch of raw data from the logs, but rather information that can be handled quickly and conveniently.</h3><p>Machine learning is part of artificial intelligence technologies that allow analytical systems to see patterns in raw data. It is used for recognizing objects in photos and videos, combating security threats and financial fraud, balancing traffic in telecommunications infrastructures, etc.</p><p>The problem-detection platform uses machine learning to detect early signs of failures in logs. Unlike humans, it is easy for a robot to look through tens of thousands of log chains and find the telltale signs of technical failures. A trained model can use the accumulated experience to record future problems in the same way. From this data, engineers can decide: either get the bug into development or skip it because it’s a typical bug. As a result, support gets rid of routine, its efficiency increases qualitatively.</p><h3>How it works</h3><p>The solution consists of three applications: one analyzes the logs and saves the results of the analysis in the database, the second updates the model once a day, i.e., provides the ability to train, the third (a console utility) allows user to adjust the results for additional training of the model. Engineers also have a dashboard in Kibana, where user can immerse into the desired events.</p><p>The service collects the results of the analysis in an Excel spreadsheet, where user can see general statistics on the problems encountered, a breakdown by class and potential threat, and the dynamics during the day. The user can also see which events are regular and which occurred for the first time.</p><p>The dataset for the training model has been assembled as follows:</p><ol><li>Taking 130,000 logs from the system (this is a figure for 5 days);</li><li>Using a script to select about 3,500 unique logs with similar messages;</li><li>Grouping them into 37 files according to their level of similarity;</li><li>Filling in the descriptions by which the model assigns the error to a particular cluster and a particular group.</li></ol><h3>PDP in our practice</h3><p>Last year, the support team of our high-loaded sales system started working with the product prototype. During the very first weeks of using it, thanks to PDP support, we identified several bugs and technical problems, including a bug that was affecting a critical business process.</p><p>Over the first months, the work was routine as it was necessary to train the model. To do this, engineers manually marked errors in incoming logs. We worked on tens of thousands of logs so that PDP could learn to detect errors in them.</p><p>And over time, the results became more and more obvious. The main thing is that it has become possible to work efficiently with a large number of log entries. There are now about 58,000 events a day, and unlike humans, the system reads every line. Our tech support sees the dynamics of known cases and quickly notices errors which were previously unknown.</p><p>All of this is very valuable information for the tech support. For example, you can see that a few dozen errors can be more serious than a thousand incidents. If the latter are spread over a 24-hour period, there may be no problem, and the errors are technical in nature. But a peak of a small number of errors in a short time can be a threat.</p><p>In practice, this means that the team does not find out about problems from the customer or users, but releases a hotfix literally within half an hour of release which is a true figure.</p><h3>What do we plan to do next?</h3><p>At the moment, the service is at the prototype stage. The ultimate goal is to make true MLOps with automatic and continuous data collection processes for training, model retraining, and model publishing. Plus, technologies to provide fault tolerance and scaling under load and continuous maintenance during operation.</p><p>To reduce the manually performed work of the helpdesk and the involvement of specialists in PDP, you need to define the criticality of events and more precisely and correctly assign them to one of the classes. In machine learning theory, the work of identifying new features is called Feature Engineering. As a result, PDP will only sound the alarm when support really needs to pay attention to bugs.</p><p>Another important direction is to handle medium-critical errors, if their number starts to grow rapidly. Sometimes, a dense flow of not-so-significant failures indicates serious problems — such cases may not alarm PDP, but they must be caught. To implement this qualitatively new feature, an additional model will be added to the system.</p><p>Let’s not forget about UX. Now the support team looks at logs in Kibana, while event analysis and retraining of the model is done in Excel. The final version of PDP will have a single window to look at a summary of errors in a class, postmark events and send data for re-learning. We also plan to implement predicative input, so that the system will suggest already known problems for entered characters or inform us that a similar chain has already been marked in the past.</p><p>However, according to the support feedback, already at the prototype stage PDP has proven its usefulness:</p><p>“The picture in terms of the criticality and frequency of problems that arise looks objective. Already in its current form, the tool has become a masthead for post-release launches, thanks to the fact that you can identify errors instantly.”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27cc0b02b716" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/machine-learning-how-we-use-it-in-tech-support-27cc0b02b716">Machine Learning: How We Use It in Tech Support</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Developer in Test: Dropping Regression Testing]]></title>
            <link>https://medium.com/trueengineering/software-developer-in-test-dropping-regression-testing-51d3b4f0ef95?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/51d3b4f0ef95</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Thu, 15 Jul 2021 16:32:03 GMT</pubDate>
            <atom:updated>2021-07-15T16:32:03.600Z</atom:updated>
            <content:encoded><![CDATA[<p>Today we’re going to take a closer look at how we’re transforming our testing processes by means of implementing automation standards and embedding automated test plans into the development process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hoOBXQF1gZLE_Q1G" /></figure><p>Early last year, here at True Engineering we formulated a corporate strategy of “Shared Engineering”, in which we develop our base of approaches and standards and unify our workflow. We developed uniform requirements for project management, as well as for the architecture, deployment, and support of our products.</p><p>To optimize the testing process, the main goal of which was to reduce the time-to-market (TTM) of products, we adopted the SDET (software developer in test) concept. It implies that a QA engineer accompanies a product throughout its lifecycle, rather than joining testing at the very end. This approach guarantees us not only reduced testing time, but also continuous quality control.</p><h3>How do we bring SDET into our teams working?</h3><p>From our perspective, SDET is a certain set of functions from drawing up a general testing strategy to writing automated tests and manual testing, if required. These functions can be assigned to an individual specialist, but we have chosen distributing them within our teams.</p><h3>General requirements for the testing process for all teams</h3><ul><li>Regression checklist in Azure DevOps which built into the CI/CD;</li><li>Set of auto tests covering the regression checklist;</li><li>Reports in the context of the regression checklist on the results of the run;</li><li>Making a checklist before you start developing a feature;</li><li>Development of autotests by checklist;</li><li>Metrics of test plan coverage by autotests.</li></ul><h3>Customizing Azure DevOps Pipelines</h3><p>Azure DevOps Pipelines allow running automated tests and have a report on them. However, it was unclear how to align this report with a checklist and generate it in the required form. Taking that into account, we developed a custom extension for Azure DevOps that associates autotests and test cases.</p><h3>How our teams implement SDET principles into their work</h3><ul><li>Set up a test environment and Azure DevOps pipelines;</li><li>Define types of autotests for code coverage: unit tests, integration tests, scenario tests;</li><li>Learn to write appropriate types of tests according to our standards;</li><li>Make a plan to write automated tests to test key functions;</li><li>Set up autotest reports based on test plans;</li><li>Develop a roadmap and plan to implement SDET in the project, agree with the customer and include appropriate tasks in the sprints;</li><li>Select and configure a tool to measure code coverage (Sonar Qube, JaCoCo or Cobertura). This is only relevant for Unit tests as the task is to control and maintain the required degree of code coverage.</li></ul><p>Autotest code coverage is a process that can last for an unlimited period of time, and you have to conduct it properly. We always carefully calculate the amount of coverage needed against the criticality of the functions to be covered and costs for it. First, not all of the features are well tested by autotests. For example, it is time consuming to manually test features with monotonous and clearly described logic, but it is an ideal option for automated testing. At the same time, small tweaks like changing colors on one button will be easier to test by hand.</p><p>Second, our experience shows that the level of automation should be quite high, but it can only approach 100% on products that are not evolving. In an environment where the market and business respond almost instantly to innovation, products need to be flexible and proactive. TTM and the ability to change the product to meet new ideas and challenges play a key role here.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=51d3b4f0ef95" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/software-developer-in-test-dropping-regression-testing-51d3b4f0ef95">Software Developer in Test: Dropping Regression Testing</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Seamless migration of a monolithic frontend]]></title>
            <link>https://medium.com/trueengineering/seamless-migration-of-a-monolithic-frontend-4d8e3eaebb5f?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/4d8e3eaebb5f</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Thu, 01 Jul 2021 03:12:46 GMT</pubDate>
            <atom:updated>2021-07-01T03:12:46.678Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Some time ago, we had to modernize the frontend monolith of a large high-loaded system running 24/7 transferring it from the outdated Knockout framework to modern React. We want to share our experience on how to facilitate such a project.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FhoDr6M0NfRerCKs" /></figure><p>The challenge arose when the used architecture became outdated and inadequate to business requirements. The team developed new features, but it was almost impossible to implement them in the existing architecture.</p><p>The main part of our product is a single business scenario, whose individual modules are closely interconnected. It can’t just be rewritten from scratch as it is a separate project with its own funding. And while the development process is underway, we will have to maintain two versions at once, one of which will also be unserviceable, since none of the parts of the application is valuable on its own, without any connection to the other parts. In view of that, we started rewriting it module by module and window by window.</p><p>One of the key requirements of the project was that the transition should be seamless for users. That’s why all the changes were hidden inside: our developers had built data exchange between the old and new framework, debugged it upon testing that revealed some faults inherent in such a non-standard architecture.</p><p>When we began to select options for upgrading, we settled on React. Now it is one of the most popular frontend development tools in the world. It interacts well with other tools that may be needed in each specific project, allowing to create scalable web apps of any level of complexity.</p><p>Next, let’s talk in more detail about the specific challenges we had to face during the migration and how we met them.</p><h3>How to build a target architecture</h3><p>You can’t do without temporary solutions in such a project, but they all have to be on the old side (that is, in our case, on the Knockout side). React modules immediately work the way we want them to, and other product components adjust to them.</p><p>Hence the rule is as follows. All data comes from React that defines the format and content. The task of integration wrappers is to adapt this data for processing on Knockout.</p><p>When the migration process is over, all crutches along with the old modules are removed from the system by switching the feature toggle, and the service immediately works as it should.</p><h3>How to make two generations of frameworks work together</h3><p>Knockout and React handle data in fundamentally different ways. The challenge is to make sure that all modules, no matter what they are written on, understand in time what happens to the data and how it changes.</p><p>To enable older Knockout modules to work with React components, the team created integration bindings. As a result, data can be changed on both the Knockout side and the React side. The cyclic script tracks changes in both parts of the application to handle such situations properly:</p><ol><li>When you change data on the Knockout side, the changes are immediately pushed to React.</li><li>If the change request comes from the React side, the changes are first applied to Knockout and then routed back to React according to a well-established scheme.</li></ol><p>This saves us from the threat of an endless loop, where a change in Knockout data causes a change in React, and the resulting change in React causes it again in Knockout.</p><h3>How to account for changes in different layout modules</h3><p>The second tricky part was the different ways of creating HTML markup on the screen. When you embed a React component in a Knockout layout, the internals of the component work properly, but if the view module is removed from the page by Knockout, the React component is not aware of this and the JavaScript will not handle this script in any way.</p><p>React will “think” that the component is still on the page, will try to do something with it, change data, send requests, etc. As a result, the memory leaks and the interface freezes.</p><p>To prevent this, the team has implemented a mechanism to track changes in the layout using the browser-based MutationObserver API. When a container with a React component disappears, it calls the necessary methods to have that component unmounted by React as well.</p><p>With these two integration mechanisms, we were able to combine React and Knockout components in a user script. As a result, the user walks sequentially through the script and no data is lost. You can go back from any step and all the information you entered will be on the screen as you expect to see it. And the final window with all the options is displayed correctly. We can rewrite a large and complex application step by step instead of writing code only to set it aside for a year or two.</p><h3>How to simplify testing and approval of UI elements</h3><p>It is crucial for the team having the ability to quickly develop and test UI elements. We use the Storybook library for this. It’s a separate web page with its own interface, which is like a kind of store for all the UI components we develop. They exist in Storybook separately from the main appl. This approach allows us to firstly remove the dependency on the backend and the environment, and secondly, it’s easy to emulate any scenario with mock data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/596/0*R9LWyA6_Dxt--nj6.png" /></figure><p>The block on the left collects all the elements that are on the page being developed. The designer can drag and drop them, combine them, and see how different components work together and individually. The sliders at the bottom can adjust the appearance, and the adjacent tab contains all the possible actions that can be done with the layout.</p><p>When working in Storybook, our backend module automatically stops sending real requests and returns mock data instead, even though everything looks exactly the same from the component side. We have developed mechanisms for generating test data based on the Faker library. If there is a new component that needs to get user or document data, you don’t need to create new stubs and maintain them in multiple files throughout the project in case of contract modifications. It’s enough to call the appropriate mock generation method and the test data will be ready, and in case of changes you only need to maintain it in one place.</p><p>In addition, the use of Storybook allows for intermediate acceptance of the visual components of the system. For this purpose, we deployed it in the UAT environment, where all tasks are accepted by the customer. By looking at the Storybook, our customers can see at any time how components are being developed, what new components have appeared and what has changed in the old ones.</p><h3>Conclusion</h3><p>Every alike project is unique, a lot of details depend on which particular framework you’re migrating from. Two top tips from our front-enders:</p><ul><li>Move immediately to the ideal picture of the world and build all the compromises on the side of the framework, which you give up.</li><li>Create a comfortable environment for testing, use Storybook-like tools.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d8e3eaebb5f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/seamless-migration-of-a-monolithic-frontend-4d8e3eaebb5f">Seamless migration of a monolithic frontend</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[S7 Sigma: analysis and accounting of services from global booking systems]]></title>
            <link>https://medium.com/trueengineering/s7-sigma-analysis-and-accounting-of-services-from-global-booking-systems-102e3af2d060?source=rss----af628329a24d---4</link>
            <guid isPermaLink="false">https://medium.com/p/102e3af2d060</guid>
            <dc:creator><![CDATA[TrueEngineering.co]]></dc:creator>
            <pubDate>Thu, 10 Jun 2021 05:43:54 GMT</pubDate>
            <atom:updated>2021-06-10T05:43:54.048Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>The True Engineering team automated the processing of documents from global distribution systems (GDS) for the Russia’s largest private airline S7. The solution guarantees transparency in settlements with international partners. S7 employees are saved from manual labor that took them several days every month — now the process takes place in a couple of hours.</strong></p><blockquote>S7 Sigma is an accounting system that provides online processing of air travel transactions. It allows S7 employees not to manage settlements with the ticket selling agents and partner airlines manually. The system automatically processes flight data, generates invoices for interline partners, facilitates creating claims for agents — almost in real-time and with minimal involvement of airline employees.</blockquote><p><strong>GDS on the Aviation Market</strong></p><p>To sell tickets on international markets, airlines enter into agreements with the Global Distribution System (GDS). The largest such system is Amadeus, there are also Saber, Abacus, and others.</p><p>The work of airlines with GDS follows the same principle that we privately use with our cell providers. GDS charges money for making reservations, cancellations, and other transactions with their services. A certain number of such operations are included in the subscription fee; airlines pay extra for exceeding the limit — this is a normal practice.</p><p>Monthly service charges amount to hundreds of thousands of dollars, and the excess of the subscription fee takes a big part in this sum. Detailing for the services received comes in the form of BIDT documents (Billing Information Data Tapes). Airlines want to cut their costs and there are two ways to do this:</p><ol><li><strong>Get compensation from agents.</strong> To do this, you need to find in the list of transactions with GDS illegal transactions that violate the policy of the airline. For example, agents are not allowed to create test bookings to estimate ticket prices, cancel bookings too close to flight dates, etc. If the agent carries out such actions, the airline has the right to form a claim and demand compensation from him.</li><li><strong>Create a Credit Request to cancel part of an invoice.</strong> GDS generates invoices automatically, and transactions that should not actually be paid are included in the list of operations. We will not go into the details of these specific cases — the main thing is that the airline can indicate these transactions, and GDS will agree to reduce the bill.</li></ol><p><strong>How the process went before</strong></p><p>Previously, when GDS sent an invoice at the end of the billing period, S7 employees had to dive into the BIDT specifications. They manually searched Excel tables for transactions to form claims or credit requests. The claims data was then passed on to the agent department, so that other specialists get compensation from the agents, also manually.</p><p>All this required the participation of five S7 specialists and took several days. It is practically impossible to process the entire amount of data to find all the discrepancies to a single one. Therefore, employees had to focus on the most common cases, which are easiest to find in BIDT.</p><p><strong>How Sigma automated these operations</strong></p><p>Now the True Engineering team has created a special service that automated all stages of the process as much as possible: searching for illegal transactions, creating agency claims, preparing a Credit Request.</p><p>This tool is guaranteed to identify all abusive transactions in BIDT — whether they are illegal actions of agents or mistakenly added transactions from GDS. The airline can be sure not to overpay for service. Another important consequence is the ability to track and analyze the dynamics of consumed services. For example, this way one can notice on time that agents are too actively promoting (looking for and booking) unprofitable destinations. In its relationship with GDS, the airline receives absolute transparency of mutual settlements, that can be fixed in an SLA.</p><p>The main functions of the service:</p><p>• Unification of data from exchange files coming from GDS (six GDS — six different formats and encodings).</p><p>• Automatic search for violations based on 10 checks, calculation of penalties based on the GDS rate and S7’s administrative costs, conversion of amounts into the currency used by each specific agent.</p><p>• Preparation of claims describing the violation by IATA (International Air Transport Association) standards.</p><p>• Formation of a Credit Request according to the format of each GDS, which accepts such claims (four different formats).</p><p>The service maintains its own system of directories with types of violations, penalties, which vary depending on the sales channel, region, and other conditions.</p><p>The whole process takes place by pressing several buttons — from information processing to filing a claim. S7 employees do not have to spend weeks working with Excel spreadsheets, and the airline itself can direct their free hands to other tasks.</p><p><strong>Following plans</strong></p><p>The True Engineering team continues to automate the GDS and agent processes so that airline employees don’t have to click anything at all.</p><p>Based on the results of the billing period, the system will automatically look for violations in the lists of operations, it will itself form claims and Credit Requests. Professionals will simply receive notifications that data can be sent to an agent or GDS.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=102e3af2d060" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trueengineering/s7-sigma-analysis-and-accounting-of-services-from-global-booking-systems-102e3af2d060">S7 Sigma: analysis and accounting of services from global booking systems</a> was originally published in <a href="https://medium.com/trueengineering">True Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>