DevAssistant

A month, dozens of services, and zero downtime allowed. A tough challenge, but a fascinating engineering one. Here's how it all came together.

You have one month, dozens of services, and a strict no-downtime policy. What do you do first?

This was exactly the situation when we helped an international ride-hailing service migrate to a new infrastructure.

Within four weeks, we had to move all services from an old Kubernetes cluster to a new one and get them up and running on an updated engineering platform – all while keeping the user-facing application fully operational with zero interruptions.

The biggest challenge? The sheer scale of the system and the web of dependencies. Databases, Redis and other storage systems, message brokers, internal microservices, external APIs – some of these connections weren’t even documented in the configs and only came to light during deep analysis.

In the end, within those four weeks, we successfully migrated every planned service to the new cloud environment and decommissioned the old platform – all while users continued using the service 24/7 without even noticing a thing.

We’ve detailed the entire migration process and the key strategies that helped us meet such a tight deadline with zero application downtime in our case study:
https://evrone.com/cases/wayo

And you – where would you start with a migration like this?

When we take on a project, we put not only our expertise into it but also our heart. This one was no exception.

It was truly great working on this task — a lively process, tough decisions, and genuine involvement from everyone. We're glad our experience came in handy and truly appreciate the trust placed in us.

We're moving forward in high spirits with new plans!

The most expensive mistake in infrastructure projects is starting to choose tools too early.

We have an interesting case. The client is a top-tier research laboratory – we can't disclose the name due to NDA. Their pain point: despite having a powerful pool of professional GPUs, engineers were wasting time waiting. Graphics cards were being reserved entirely even for small tasks, resource allocation between teams was done manually, and expensive equipment sat idle.

We didn't jump straight into designing the future platform's architecture. Instead, we started with experiments: we tested different GPU scheduling approaches on the client's real workloads. This helped us understand which solution would actually fit their infrastructure.

Based on the data we gathered, we built a unified MLOps platform that automated compute resource allocation, pooled existing GPUs, and made their usage transparent for the entire team.

As a result, engineers could run tasks in parallel without waiting for access to compute resources, and management got full visibility into infrastructure utilization.

Good architecture doesn't start with tool selection. It starts with understanding the problem.

Read more about the project on Evrone's website: https://evrone.com/cases/relab

A solid read for anyone considering a move to Rust. The authors honestly lay out where it delivers (memory, speed, legacy code) and where it only creates more problems. Worth reading before making a decision.

Something interesting has happened with Rust.

Just a few years ago, people were mostly arguing about it. Some said it was the future of development, others thought it was just another overhyped trend.

Now there's less arguing. But there are a lot more practical questions. For example, whether it's worth migrating an existing product to Rust.

And this is usually where it turns out that the question isn't really about the language at all.

Because there's a golden rule: if it ain't broke, don't fix it. If the system is well-tuned, the team is happy, and business goals are being met – migration can end up being an expensive endeavor with little noticeable return. But if you've accumulated issues with performance, security, or maintaining legacy code – that's a whole different conversation.

In an article with Evrone's DevRel Grigory Petrov, we broke down the situations where switching to Rust might actually be justified. And a few cases where it's better not to redo something that's already working just fine.

https://evrone.com/blog/migrating-to-rust-in-2025

On the surface — a clean and intuitive interface; underneath — serious work on architecture and business logic. That was exactly the approach taken in modernizing the Mindbox platform. We were able to join this stage and contribute to reworking the user scenarios. The results speak for themselves: the product became more convenient without becoming internally more complex.

Redesign isn't always about a new look. Often, as a product grows, there comes a point where updating the interface alone is no longer enough.

That's exactly what Mindbox ran into during their platform modernization. It's a cloud service for marketing automation – email campaigns, personalization, loyalty programs, plus customer data management without overloading the client's internal IT systems. The product is complex, and its frontend had become a bottleneck for further development.

Together with the client's team, Evrone developers took part in updating the frontend architecture and reworking key user scenarios. As a result, reports became much more convenient, working with data became clearer, and setting up recommendations became simpler.

At the same time, the most important changes weren't happening on the screen. Behind an interface that looks simple and intuitive to the user, there's usually a significant amount of work on architecture, product logic, and internal processes. It's these kinds of changes that allow a product to keep growing without constantly becoming more complicated.

More about the project:
https://evrone.com/cases/mindbox

Go has a solid standard library, so why even bother with frameworks? And if you do bother – which one actually makes sense for highload, microservices, or MVP? This article answers both questions.

When should you migrate from Ruby to Go, and when is it better to stick with your familiar stack? Our colleagues have published a piece that breaks down all the arguments for and against. No extremes, just to the point. The link is in the post.

Migrating from Ruby to Go: when it makes sense and when it's a mistake

A Ruby project worked steadily for years, but then the load grew, response time increased, new features became a struggle, and everyone around started saying: "Switch to Go."

Is it worth abandoning your familiar stack? Let's explore this together with Alexander Kirillov, a DevOps expert and mentor in the Evrone DevOps internship program.

Go is faster under load because it compiles to machine code. Built-in goroutines simplify parallel computing. Static typing catches errors at compile time. The final binary is easy to deploy.

But there are trade-offs. The Ruby ecosystem is richer – many things in Go would have to be written from scratch. The language has strict rules: even an unused variable will prevent compilation. There are no classes or inheritance – only structs and interfaces.
Migrating a large project takes months, plus retraining the team.

To make the right decision, assess your actual problems. If current performance is no longer satisfactory – Go might help. If everything runs fine, the switch may not be worth the effort. Start by rewriting one microservice in Go, not the entire project.

And if you want to try Go but find it daunting, we can help with migration – from a test prototype to a full project rewrite.

All the details – which approach to choose, how to test, and whether to start at all – are in the article.
https://evrone.com/blog/from-ruby-to-go

A non-standard approach always delivers great results. Here is a case study we contributed to.

When standard solutions just don't fit your needs anymore, sometimes the only way is to build your own. We helped make that happen. Check out the results.

Today we are talking about the Kinderlime platform, which we worked on.

Need help scaling your EdTech platform? Here's how we tackled this challenge. You can reach out to Evrone with a similar challenge: [email protected]

We at Evrone are used to complex projects, but Kinderlime is a different story.

It’s an app for private daycare centers and preschools in the US. It handles all the administrative work: contactless check-in and check-out, payment collection, staff management, and enrichment programs. In short, everything that helps educators focus on the children instead of paperwork. The service is popular – more than 30,000 centers use it.

The client came to us with an existing Rails application. But the business was growing, the feature set was expanding, and the monolith was starting to slow things down. The goal was to separate the frontend and backend via a REST API and build a new frontend based on ready‑made mockups.

Here’s what we did. We wrote a library on top of Redux and Axios that generates API requests, reducers, and response handling. Without it, we would have had to write the same code hundreds of times. We also built a custom form builder from scratch: support for custom questions, multi‑step forms, and custom fields. We added a CRM with dashboards that collect all conversion analytics. We built an email builder as well – custom campaigns, mailing list management, automated notifications to parents of enrolled children – all while ensuring correct rendering in Outlook, Apple Mail, Gmail, and other clients.

On the technical side: React, Redux, Webpack, Stripe integration, CircleCI for continuous integration, AWS for storage, and Cypress for testing – we achieved 90% test coverage.

In the end, Kinderlime didn’t just get a modernized product; they gained transparent communication and an effective engineering team that integrated smoothly with their product team. The new features and interface helped attract even more customers.

EdTech is never easy, especially at the scale of thousands of educational institutions. If you have a similar challenge – reach out, we’re ready to help.
https://evrone.com/cases/kinderlime

We are always happy to take part in working on a cool project.