Modern eCommerce platforms need to scale quickly, remain cost-efficient, and stay deeply integrated with ERP systems. Traditional hosting models — fixed servers, VM clusters, or monolithic platforms — make this increasingly difficult.
At ERPGAP, we have been running Alokai + Odoo on Google Cloud Run in production. This setup has proven to be highly scalable, performant, and cost-effective, while keeping Odoo firmly in control of business logic and data.
This article explains why Cloud Run fits Alokai so well, how Redis (Memorystore) fits into the architecture, and why this stack is especially suited to companies serious about scaling eCommerce without scaling their entire ERP.
Alokai in a Nutshell
Alokai is a modern headless commerce frontend built on Nuxt.js and Vue. It is designed to deliver fast, flexible storefronts while integrating with backend systems such as ERPs.
Its strengths are clear:
- Frontend fully decoupled from backend constraints
- Excellent performance and SEO
- API-first by design
- Well suited to ERP-driven commerce
Alokai does one thing very well: customer experience. It does not try to replace ERP logic — it integrates with it.
For a deeper introduction:
Headless eCommerce with Odoo
When paired with Odoo, Alokai becomes the frontend layer on top of a powerful ERP.
Odoo typically manages:
- Products, variants, and attributes
- Pricelists and pricing rules (B2C & B2B)
- Stock, availability, and warehouses
- Customers, orders, invoicing, and accounting
Odoo remains the single source of truth. Alokai focuses purely on speed, UX, and scalability.
This separation is what makes the architecture cloud-native and future-proof.
Who This Stack Is Really For
Alokai + Odoo is usually chosen by companies that:
- Expect significant traffic growth
- Treat eCommerce as a core business channel
- Run complex pricing, stock, or multi-country setups
- Need all orders inside Odoo, not in a third-party platform
In short: this is typically a solution for larger or more committed eCommerce clients, where scalability, performance and integration are business-critical.
Scaling Without Scaling the ERP
One of the most important advantages of this architecture is independent scaling.
Scaling Odoo horizontally is possible, but complex:
- Stateful workers
- Database contention
- Cron and job coordination
- Higher operational cost
- Filestorage and session store scaling
Alokai, on the other hand, is stateless.
It is simply:
- A Nuxt.js (Node.js) application
- Packaged as a Docker container
- Fronted by an NGINX sidecar
This means you can scale the storefront aggressively without scaling the ERP.
We’ve validated this with real load testing:
This approach protects Odoo, keeps costs predictable, and absorbs traffic where it should: at the frontend layer.
Composable Commerce, in Practice
This setup follows the principles of Composable Commerce:
- Best-of-breed components
- Clear system responsibilities
- API-driven integration
- Independent scaling and evolution
In this architecture:
- Alokai → Frontend & UX
- Odoo → ERP, orders, finance, stock
- Redis → Caching & performance
- Cloud Run → Hosting & scaling web app
Each part does its job — and does it well.
Why Google Cloud Run?
Making a Hard Problem Simple
Running a scalable storefront traditionally means dealing with:
- Server provisioning
- Capacity planning
- Load balancers
- Autoscaling rules
Cloud Run removes all of that.
You deploy a container — Google handles the infrastructure.
There is:
- No hardware to provision
- No servers or node pools to manage
- No over-provisioning “just in case”
Cloud Run scales per request, automatically.
Cloud Run vs Kubernetes
Kubernetes can also scale Alokai — and in some cases it’s the right tool. But it comes with real overhead:
- Cluster management
- Node sizing
- Autoscaler tuning
- Slower reaction to sudden spikes
For a stateless Nuxt.js application, Cloud Run offers:
- Faster elasticity
- Lower operational complexity
- Better cost efficiency at low or variable traffic
It turns a traditionally DevOps-heavy problem into a simple deployment model.
Our Cloud Run Architecture for Alokai
Alokai Container + NGINX Sidecar
- Alokai runs as a Docker container
- NGINX runs as a sidecar
- The service is fully stateless
NGINX is used to:
- Control routing and headers
- Improve delivery performance
- Keep the application container clean
Redis (Memorystore)
Cloud Run integrates cleanly with Redis via internal networking.
We use Redis to:
- Cache API responses
- Reduce load on Odoo
- Improve time-to-first-byte
Because the connection is internal, latency is minimal and security is improved.
Proven in Production
This is not theoretical.
We run Alokai + Odoo on Cloud Run in production for:
- B2C storefronts
- B2B portals
- Multi-country pricing
- High-traffic campaigns
Traffic growth is absorbed by Alokai, while Odoo remains stable and predictable.
When This Architecture Makes Sense
This setup is a strong fit if you:
- Want a modern headless storefront
- Use Odoo as your ERP backbone
- Expect variable or seasonal traffic
- Need ERP-level order integration
- Want minimal infrastructure management
Final Thoughts
Google Cloud Run is an excellent match for Alokai. Combined with Redis and a clean container architecture, it enables a scalable, composable, and cost-efficient eCommerce platform — without turning your ERP into a bottleneck.
For companies that see eCommerce as a strategic growth channel, this is one of the most effective architectures we’ve seen — and one we confidently run ourselves.
Learn More
- Headless eCommerce with Odoo
- Scaling Alokai under load
- Alokai & Odoo Integration
- Cloud-Native Odoo Architectures
ERPGAP designs, implements, and scales modern ERP-driven commerce platforms — from strategy to production.
Official Odoo Partner
