I used Rust in production for 6 months! Here's my feedback
What is Qovery?
Qovery is a Cloud deployment platform used by more than 1000 developers to deploy their apps on AWS. The part in app deployment is written in Rust (take a look, it's open-source). My team and I enjoy technical challenges, and when we decided to move out of Python (for robustness reasons), I suggested Rust!
Why Rust?
Qovery is installed on the Cloud account of our customers! Meaning, we need to be 100% sure that when Qovery is installed, it will run forever with a minimum memory and CPU footprint. This is a critical piece of our product. It's a bit like launching a satellite into space. Once it's launched, it's nearly impossible to repair it physically.
This is where Rust shines. Once it's compiled, it works like a charm.
Why not use Go?
What we're doing with Rust could be done with Go. However, from my experience, I saw a lot of devs abusing Goroutines (lightweight threads), leading in concurrency issues. Rust prevents misuse of threads, which can be frustrating - but for good reasons.
Feedback
Don't expect new programmers to be productive in the first month.
There is a learning curve associated with each programming language. Like other languages, developers new to Rust will take time to learn the concepts, play with code, and be productive. You should not expect them to be effective in the first month itself. I'd recommend spending time to dig into crucial concepts like Borrowing, Ownership, and Lifetime to understand Rust better. I'd also recommend reading the official book on Rust programming language, which is available at - https://doc.rust-lang.org/book/.
Rust changes the way we build applications for the better.
Due to the excellent type system, Rust is safe by design, and it changes the way one builds applications positively. "Don't fight the borrow checker", spend time to understand why it throws you to error - it's for your good. You're probably doing something "wrong" for years without knowing. Personally, it was my case when developing concurrent features on other programming languages like Java and Go. So, don't fight the borrow checker, and embrace it :)
The tooling is good
Rust has some great tools like 'Cargo' which is a Rust dependency manager. Cargo helps build code, download the libraries that the code depends on, and build those libraries. Suppose you are a Java or Kotlin developer and are familiar with IntelliJ IDEA, which is an integrated development environment in Java. In that case, you do not have to fear as there is an excellent Rust plugin available.
For me, the IntelliJ debugger works fine, but it may get challenging to get details on the variables when they are allocated on the heap. Here the LLDB debugger can help with ease. Which I honestly... don't use.
You may not find the library that you need.
The Rust programming language has a lot of high-quality libraries. But the Rust ecosystem is not mature like Go, Python, or Java. In case you are unable to find something suitable, you will have to create it. This is an excellent and creative opportunity to contribute to the Rust ecosystem. The community developers are always looking for exciting things on Rust, and your contribution will help the community. That's why we open-sourced our deployment engine — trying to contribute to the Rust ecosystem in our way.
Error handling can be verbose.
Even though error handling rust may be verbose, it is good to handle all cases. There are mechanisms like the '?' operator that aims to reduce the volume of error handling code, but at some point, like for me, you will have to handle it. But this is also why Rust is so safe, and you have to spend time handling errors instead of skipping them.
The compilation is so slowwwww
Depending on the size of your project, it will take time to download the libraries and build them and could take between one to ten minutes. At Qovery, we started with 2 minutes and 30 seconds of compilation time, and today, it is at 8 minutes. However, the Rust team has been making improvements to make the compilation faster through incremental builds.
Note: Pierre (CTO of Qovery) configured a distributed cache with SCCache, and we reduced build time per 2.
Rust has a strong community.
Rust programming language is excellent, but mainly the people who form the Rust developer community make Rust a great ecosystem. The community stands for equality and welcomes all. It is small and growing fast. The Rust tooling ecosystem is very active, enthusiastic, and growing, which has all the makings to spearhead Rust into a widely used language. I also try to contribute with Qovery and my free time to create new content to show that Rust is accessible to anyone - even with experience in only a high-level programming language.
Conclusion
Rust is becoming popular day by day, with greater adoption of Rust by organizations in the Cloud computing sphere. Rust language has many advantages and is the perfect language to build highly resilient applications. As developers gain productivity, you must think positively of the slightly longer learning curve and be patient in the first few weeks. These little investments will go a long way to improve ways to design apps. Rust has exciting career options, and we at Qovery believe in a bright future for Rust in the coming years.
If you are excited about Rust (as we are) - drop us a line :) Stay safe.
.svg)
.svg)
.svg)
Suggested articles
Agentic Kubernetes resource reclamation is the practice of using an autonomous control plane to continuously identify, suspend, and delete idle infrastructure across a multi-cloud Kubernetes fleet. It replaces manual cleanup and reactive autoscaling with intent-based policies that act on business state, eliminating the configuration drift and cloud waste typical of unmanaged fleets.
Kubernetes focuses on container orchestration, but the reality on the ground is far less forgiving. Provisioning a single cluster is a trivial Day-1 exercise. The true operational nightmare begins on Day 2. Teams that treat multi-cloud fleets like isolated pets inevitably face crushing YAML configuration drift, runaway AWS bills, and severe scaling bottlenecks.
The shift from AI copilots to autonomous agents is redefining infrastructure requirements. Discover how to build secure, stateful, and compliant Agentic AI systems using Kubernetes, sandboxing, and observability while meeting EU AI Act standards
Effective Kubernetes management in 2026 demands a shift from manual cluster building to intent-based fleet orchestration. By implementing agentic automation on standard EKS, GKE, or AKS clusters, enterprises eliminate operational weight, prevent configuration drift, and proactively control cloud spend without vendor lock-in, enabling effective scaling across massive fleets.
A Kubernetes single pane of glass is a centralized management layer that unifies visibility, access control, cost allocation, and policy enforcement across § cluster in an enterprise fleet for all cloud providers. It replaces the fragmented practice of switching between AWS, GCP, and Azure consoles to govern infrastructure, giving platform teams a single source of truth for multi-cloud Kubernetes operations.
Deploying a Docker container on Kubernetes requires building an image, authenticating with a registry, writing YAML deployment manifests, configuring services, and executing kubectl commands. While necessary to understand, executing this manual workflow across thousands of clusters causes severe configuration drift. Enterprise platform teams use agentic platforms to automate the entire deployment lifecycle.
Optimizing Kubernetes on AWS is less about raw compute and more about surviving Day-2 operations. A standard failure mode occurs when teams scale the control plane while ignoring Amazon VPC IP exhaustion. When the cluster autoscaler triggers, nodes provision but pods fail to schedule due to IP depletion. Effective scaling requires network foresight before compute allocation.
At enterprise scale, managing provider-specific Kubernetes YAML across multiple clouds creates crippling configuration drift and operational toil. By adopting an agentic Kubernetes management platform, infrastructure teams abstract cloud-specific configurations (like ingress controllers and storage classes) into a single, declarative intent that automatically reconciles across 1,000+ clusters.
.webp)