From Azure VM to Azure Container Apps: How We Reduced Hosting Costs by 70% Without Rewriting Our FastAPI Backend

Humayun — Mon, 08 Jun 2026 11:11:36 +0000

A few weeks ago, a routine Azure billing email made me take a closer look at our infrastructure.

At GoPanda (https://gopanda.in), we're still an early-stage startup. Our traffic is relatively low, and our FastAPI backend was comfortably running on an Azure Virtual Machine.

The setup worked.

The problem was that the VM cost the same whether we received 10 requests a day or 10,000.

We were paying for uptime, not usage.

That realization led me down a rabbit hole that eventually ended with a complete migration from Azure Virtual Machines to Azure Container Apps (ACA).

What started as a cost optimization exercise ended up being a great lesson in modern cloud infrastructure.

The Original Architecture

Our backend stack was fairly straightforward:

FastAPI
Docker
Azure Virtual Machine
GitHub Actions for deployments

The application itself was already containerized, so deployment wasn't particularly difficult.

However, the VM came with a few drawbacks:

Fixed monthly cost
OS maintenance and patching
Paying for idle compute
Manual capacity planning
Infrastructure tightly coupled to a specific machine

For a startup still validating and growing its product, these tradeoffs didn't feel ideal.

Why Azure Container Apps?

Initially, I evaluated several options:

Continue using Azure VM
Move to Azure Functions
Use Azure Kubernetes Service (AKS)
Use Azure Container Apps

Azure Container Apps ended up being the most practical choice.

The simplest way I can describe ACA is:

Kubernetes without having to manage Kubernetes.

Azure handles:

Cluster management
Networking
Ingress
Scaling
Control plane operations

Meanwhile, developers focus on:

Containers
Deployments
Application logic

You still get features such as:

Revision-based deployments
Autoscaling
Traffic splitting
Service discovery
Managed ingress

Without operating a Kubernetes cluster yourself.

For small teams, that's a very attractive tradeoff.

Why We Didn't Choose Azure Functions

This was the most obvious alternative.

After all, if the goal is lower costs and serverless infrastructure, Azure Functions seems like the natural choice.

The problem was that our backend is a traditional FastAPI application.

It relies on:

Routing
Middleware
Authentication
Long-lived API patterns

Moving to Functions would have meant adapting the application around a different execution model.

Our objective wasn't to become serverless at the code level.

Our objective was to become serverless at the infrastructure level.

Azure Container Apps allowed us to keep the existing architecture largely unchanged while gaining:

Managed infrastructure
Autoscaling
Better cost efficiency
Container portability

Most importantly, our deployment artifact remains a standard Docker image.

Challenges During Migration

1. Azure Student Subscription Restrictions

One challenge I wasn't expecting involved Azure Student subscription limitations.

Azure Container Registry cloud builds (az acr build) were unavailable in our subscription.

Instead, we built images locally and pushed them directly to Azure Container Registry.

Not a major issue, but definitely something to be aware of.

2. Apple Silicon Architecture Mismatch

This consumed more time than I'd like to admit.

I was building Docker images on an M-series MacBook.

By default, Docker generated ARM64 images.

Azure Container Apps expected AMD64 images.

The fix was surprisingly simple:

docker build --platform linux/amd64 .

A one-line change solved the deployment failures.

3. Configuration Management

The VM-based deployment relied heavily on server-side .env files.

Moving to ACA encouraged a cleaner approach:

Environment variables
Managed secrets
Stateless deployments

This made the application easier to deploy and reproduce across environments.

4. Updating CI/CD

We already had GitHub Actions in place.

However, the workflow needed to be adapted for Azure Container Apps.

The deployment flow now looks like this:

GitHub Push
    ↓
Build Docker Image
    ↓
Push to Azure Container Registry
    ↓
Deploy New ACA Revision

This significantly simplified production deployments.

Results

After the migration, we now have:

Infrastructure that scales based on actual demand
Revision-based deployments
Managed HTTPS ingress
No VM maintenance
No OS patching
Cleaner configuration management
Portable containerized deployments

And as a side effect:

Our monthly hosting costs dropped by more than 70%.

Final Thoughts

The most interesting takeaway from this migration is that cloud-native infrastructure isn't only useful when you're operating at massive scale.

For early-stage startups, it can be equally valuable before scale.

At this stage, my biggest constraint isn't server capacity.

It's time.

Every hour spent maintaining infrastructure is an hour not spent improving the product or talking to users.

Azure Container Apps helped reduce that operational burden while lowering costs at the same time.

For our current stage, it turned out to be a better fit than both a traditional VM and Azure Functions.

If you're building a containerized application and don't want the operational overhead of managing Kubernetes, ACA is definitely worth exploring.

You can check out what we're building at GoPanda:

https://gopanda.in

How I architected the backend for a local vehicle rental marketplace

Humayun — Wed, 03 Jun 2026 17:59:52 +0000

When building the backend engine for GoPanda—a digital marketplace connecting travelers with local vehicle rental shops—we needed a stack that was fast to develop with, highly performant, and type-safe.
While the React frontend gets the visual praise, the real heavy lifting happens in our Python API layer. Here’s a breakdown of the stack we chose, and how it helps us handle the complexities of a rental marketplace.

The Core Stack: FastAPI & PostgreSQL

We decided to build the API using FastAPI paired with PostgreSQL (via SQLAlchemy and Alembic for migrations).
FastAPI is arguably the best Python web framework right now for building REST APIs. The automatic Swagger UI generation and deep integration with Pydantic for validation saved us countless hours of writing boilerplate serialization code.
Here are a few specific ways this stack helped us solve marketplace challenges:

1. Complex Validation with Pydantic

A vehicle marketplace is tricky because the data structures are so diverse. The payload required to book a scooty rental in Guwahati is different from the payload required to list a premium self-drive car.
Pydantic shines here. By defining strict Pydantic models for our different vehicle types and booking requests, we ensure that bad data never even reaches our route handlers. If a shop owner tries to submit a vehicle listing without a valid price or description, FastAPI automatically returns a clean, detailed 422 Unprocessable Entity response.

2. Preventing Abuse with Slowapi

Because we act as an aggregator for local shops (like bike rentals), our search and inventory endpoints are prime targets for scraping by competitors. Additionally, we need to protect our booking endpoints from spam.
Instead of writing custom rate-limiting middleware, we integrated Slowapi. It seamlessly wraps our FastAPI routes, allowing us to define granular rate limits (e.g., 5/minute for booking attempts, 60/minute for search queries) using Redis or memory as the backing store.

3. Offloading Assets to Cloudinary

Images make or break a rental marketplace. Shop owners upload multiple high-resolution photos of their vehicles, but serving those directly from our backend server or database would destroy performance.
We integrated Cloudinary directly into our asset upload flow. When a shop owner adds a new vehicle, our FastAPI backend acts as a secure proxy—it validates the image file, generates a secure signature, and uploads it to Cloudinary. The database simply stores the optimized Cloudinary URLs. This keeps our PostgreSQL database lean and ensures images are served via a fast global CDN.

The Takeaway

Building GoPanda reinforced my love for the modern Python web ecosystem. The combination of FastAPI for speed, SQLAlchemy for robust data modeling, and Pydantic for bulletproof validation provides an incredible developer experience.

If you've got any questions, drop them below. Thank you all.

DEV Community: Humayun