What’s the best way to stay up to date with developments in the Engineering team at Payt? In our view, technical blogs are a great way to communicate this. My name is Ivan Malykh, and I’m a developer at Payt. To give you better insight into our software, we aim to write an engineering blog every month. Here’s a look behind the scenes at Payt.
When I started writing this post, I began with an introduction to one of the tools used by our front-end team – Create React App. The aim was to explain how this tool saved us considerable time and effort by simplifying the selection, installation, and configuration of various third-party packages.
However, I soon realised that our first engineering blog might be better suited to a broader perspective. So, I’ve shifted the focus slightly. Today, I’ll share a few ways our workflow boosts productivity and helps our engineers focus fully on building new features.
But first, some background on our stack.
Payt offers the most comprehensive software for credit management. Our solution consists of multiple web-based applications – primarily the Credit Management app and the Credit Management Portal. These are powered by a shared backend.
Our backend stack currently includes:
Our front-end applications use:
The front end and back end communicate via REST and GraphQL APIs and are hosted on AWS.
Payt has been around for just over eight years now. In that time, our system has grown significantly, with many new processes, features, and complex business logic. Managing this logic is no small task – but certainly not impossible.
Testing, testing, and more testing.
It may sound obvious, but many companies still don’t test their code.
At Payt, building new features always includes thorough testing. We practise Test-Driven Development (TDD), where developers write unit tests before implementing a feature. These tests are part of the codebase. If a later change breaks an existing feature, the test suite flags the problem before anything is released.
Git, Github, and Reviews
We use Git for version control. One of the most used features in our development process is branching. A branch allows a developer to work on a feature separately from the main production code.
Once the feature is ready and tested, a Pull Request (PR) is created on GitHub. A PR shows the difference between the new feature and the main branch. The PR must pass automated checks and be approved by at least one or two team members before it can be merged.
Automated quality checks
Our test suite currently consists of over 11,000 tests. Some test integration between components and take longer to run. Running the full suite locally every time would be impractical.
That’s why we use a Continuous Integration (CI) system that runs the tests for every commit. This ensures both the main and feature branches are tested before merging.
Additional automated checks include:
- Code coverage: We aim for 100% coverage and currently average above 90%.
- Code style: Enforced consistency makes the code easier to read, review, and maintain.
- API compatibility: Our backend and frontend are in separate repositories. This check ensures that any changes in the backend don’t unintentionally break the frontend.
If a check fails, the developer must fix it before the code is merged into the main branch.
Automated deployments
Developers wouldn’t be developers if they didn’t automate all their work. Thus, the deployment of developed functionalities at Payt is also automated. Every new functionality – tested and approved – is automatically rolled out to our servers.
Work in progress
Despite the number of automated workflows, the engineering team at Payt still faces many challenges. For example, we need to spend less time on configuration, administration, and other repetitive and automatable tasks. And instead, spend more time on developing new functionalities and expanding existing functionalities of our applications.
For instance, we are currently working on automating the setup of the servers on which applications run. The intention is to have our infrastructure documented in code. This will soon provide us with a single blueprint of the software required to run our applications. This speeds up the deployment of new server instances and ensures consistency between different machines.
At Payt, we’re committed to automation – not just for our customers but also within our own engineering processes. Watch this space for more insights from our development team.
