Before, I wrote about The future of software development in the cloud.
Today, I want to tell you why I'm building Stelvio and what problems it solves.
I've been writing code for 20+ years, with the last decade mostly focused on Python and cloud. Past few years I've been deep in AWS, building and deploying cloud systems daily.
Long enough to see what works, what doesn't, and where developers waste too much time.
The drill is always the same: create a function, set up an API Gateway (resources, methods, integrations), add IAM permissions, set up environment variables and so on.
I've done it a hundred times—through the console, CLI, or using IaC (Infrastructure asCode).
At some point last year it hit me.
The Problem: Cloud is Too Complex
Why am I doing this again and again? Why do I write similar configs over and over?
Why do I have to be an AWS expert to do this properly - making sure logs go where they should, permissions are tight but working, ports are closed etc.
AWS is powerful but it's huge and complex so it's hard and
tedious to get everything right.
Not because it's rocket science.
It just takes a lot of time to learn and configure everything correctly.
The worst part is that most of it is distraction from your main job (implementing business logic).
In the end the more you understand about underlying infrastructure the better. You should strive to learn and understand it but that doesn't mean you need to be expert before you start.
It shouldn't be slow and tedious.
It's hard to be expert on everything - coding complex systems as well as managing infrastructure. One distracts from the other.
Many teams need separate infra or DevOps people. While it's OK for big projects (where pace tends to be slower) it doesn't play nice with small and medium teams that need to move fast. They don't want to wait for infra guys to do their part so devs can finish theirs.
You shouldn't need an infra expert on your team unless you’re working on a very big project.
Developers should be able to handle everything themselves.
Stelvio aims to give them tools to make this much easier, effective and safe.
The Missing Piece: Current Solutions Aren't Enough
There are some existing solutions which allow you to create your infrastructure.
One of the first was Cloud Formation - only for AWS. Then came cloud independent Terraform.
These are good tools and they were revolutionary in the sense they let you define your infra as IaC. (If you consider YAML or JSON/HCL to be code :)).
But these have two problems:
- They're not real code - it's more of a config
- They're infrastructure focused
Why are these problems? It depends who's looking at it. For infra people none of this is a problem. They think in infra terms, they're experts in infra and YAML/JSON/HCL is not a problem for them at all.
But from a developer perspective it's far from ideal.
Using YAML/JSON/HCL is not the same as using Python. It's easy to learn but switching from Python to this is pain. It's like using a digger to build your app and then using a shovel to build your infrastructure.
Oh, and there is a lot of it! With Cloud Formation your templates can get to many thousands of lines pretty fast. With Terraform it's better but still far from ideal.
I've been looking for tools to make this faster and simpler.
There are tools that allow you to define your infra with actual programming language: AWS CDK and Pulumi.
They're great, you can define your infra with Python (or TypeScript, Go, C#, Java).
I'm using them daily but they still have problem #2 from above:
They're focused on infrastructure rather than developers. They aim to do everything possible in the cloud, which makes them complex.
You can use the language you want but you'll still write a lot of it.
You'll still need to write a lot of repetitive boilerplate and configurations (IAM etc.). It is less tedious but still tedious.
On the other end of the spectrum are simple deployment platforms and click-to-deploy solutions. They're super simple and cool - that's good - but they're limited (very narrow focused) and expensive (even 5x markup on top of AWS prices).
For small-medium projects you might be willing to pay more if it makes you much more productive. But I know from experience that too limited without the options of extension doesn't work in real life.
One more problem I see with these solutions is that they focus on UI instead of code (IaC).
That means you lose all the good stuff - you can't track changes, can't reproduce builds easily, can't automate properly etc.
Some of these platforms are moving towards a Framework Defined
Infrastructure (FDI) which is an interesting idea but here's the thing - real life is messy. You're often building solutions with different frameworks - so being stuck with one doesn't work.
Developers need better tools focused on DX (Developer Experience) and productivity.
With the right tools, most projects shouldn't need dedicated infrastructure experts.
I wanted something that would just work. Something that would let me write Python and deploy to AWS without thinking too much about AWS internals.
Something that would handle boring and repetitive stuff on autopilot.
The Solution: Developer-First Infrastructure
That's how Stelvio was born.
Python first approach
Python devs should use only Python to define their infra. Think about it - switching between Python, YAML/JSON/HCL and AWS Console isn't just annoying.
It breaks your flow.
When I started building Stelvio, it was clear to me it must be Python only.
With Stelvio, you stay in Python. Not because you can't learn other tools, but because it's faster and more productive.
Why IaC?
When everything is code, we get many benefits:
- Version control and history - we can track, review (in Pull Request), and reverse every infra change
- Reproducibility - dev, staging and prod environments stay consistent because they're built from the same code
- Testing & validation - we can test our infrastructure before deployment. We can catch misconfigurations and security issues through automated scans
- Automation & reuse - we can package common patterns into reusable components. CI/CD will handle deployment. No more console clicking
- Documentation as Code: Our infrastructure is self-documenting. Devs can read and understand how things work instead of relying on external (out of date) docs
Our infrastructure becomes as good as our application code.
Right level of abstraction - from top to bottom
Once we have infrastructure defined in Python, the next trick is in the right level of abstraction and control.
Infrastructure based tools focus on basic components of the cloud - core underlying constructs. You have to configure everything. UI based platforms focus on high level abstraction. It works - until you need to configure some details or do things your way.
The best way is to have a high-level abstractions with smart defaults that can be easily used with only a few lines of code. Yet every detail should be configurable - but only when needed.
Complexity should be visible, but only when it's necessary.
Stelvio aims to be a tool that will allow dev teams to ship your app without infra experts. It will make devs capable of developing, deploying and monitoring your infrastructure whether it's dev or production.
The Vision: Beyond Just Another Tool
My vision is to have a tool that will automate boring repetitive stuff and provide high-level but customizable constructs.
But it doesn't stop there.
I want to change how we work with infrastructure.
There is a whole world of things that are missing. We need a better developer experience. Not only when defining our infrastructure but also when using it, whether in development or production.
Below are some of the things I have on my list:
- easy way to create, manage and clone whole environments
- better & automated deployments
- better, easier and faster logs viewing
- monitoring
- cost understanding, analysis and prediction
- security checks
- architecture overview
- backups management
- easy way to run tests in the cloud
and many others.
The Time is Right
Why now? First, because I got frustrated with this.
But also time is right because Python has become one of the most
used languages in the world and it keeps growing. Even if we disregard its use for AI/ML it's still one of the most used languages with heavy use in the cloud.
Also cloud platforms are now very mature and it's not a new cool tool for startups.
Pydantic and Astral showed that there is a demand for better developer tools which makes them more productive and helps produce
better software.
Stelvio aims to offer such tool for Python cloud developers.
Join the Journey
Soon, I'll release the first developer preview of Stelvio as an open source project
on GitHub.
If you're interested in Stelvio:
Let's make cloud development better for Python developers, together.
I can't wait - it's going to be a great ride!
Top comments (0)