Rescuing a Geolocation SaaS Startup from a Scaling Crisis on GCP

Client Profile

An early-stage startup providing geolocation and geospatial data services to B2B customers across the Benelux region. The small backend team built and shipped the product quickly, but had no dedicated infrastructure or operations engineers.

Industry B2B SaaS (Geolocation)
Location Amsterdam, Netherlands
Company Size ~20 employees
Duration Since 2025

Technologies Used

Google Cloud Kubernetes Docker GitHub Actions Redis PostgreSQL Prometheus Grafana Jaeger

Business Challenge

The founding backend developers bootstrapped the product infrastructure on GCP the only way they knew, leaning on several proprietary managed services without a clear picture of their scaling limits and cost behaviour. It worked for a handful of clients. Then marketing ramped up, and the platform hit a wall almost immediately - it could not absorb even ten additional concurrent clients. The database was saturated, application containers were constantly starved of CPU and memory, and with no monitoring in place the team had no idea whether the app was alive, degraded, or serving correctly. To cope, they put staff on a manual rota to open the app every 5-10 minutes and exercise its functionality by hand; when it looked degraded, a developer restarted it manually. It kept the lights on, but it burned people who should have been building the business.

Solution

We ran an urgent audit and found problems across the stack. Several components were under-provisioned on CPU and RAM, there was no caching layer so every request drove heavy SQL straight at the database, and the application had been written to run as a single container, so it broke under any horizontal scaling. We enabled profiling and distributed tracing with Jaeger and Grafana to see exactly where time and resources were going, then worked alongside the client’s developers to patch the application so it runs correctly in multi-container mode. We introduced a Redis caching layer to take repeated read load off the database, and split the data path into a primary PostgreSQL node for writes and a read-replica for reads, giving granular control over database resource usage. We moved the workload onto Kubernetes for its auto-scaling capabilities and reworked the CI/CD in GitHub Actions to build and deploy to the cluster. Finally we stood up proper monitoring with Prometheus and Grafana and put the platform under our 24/7 on-call, which the client had none of their own.

Outcome

The entire change was delivered over a single weekend. It took full dedication from both our team and the client’s, but by Monday the manual restart rota was gone. The platform now scales automatically with demand, the database comfortably handles the concurrent client load that previously broke it, and the team has clear visibility into the health and performance of every component. Developers went back to building product instead of watching dashboards and restarting containers. We continue to support the environment and run 24/7 on-call on the client’s behalf.

Process

Emergency Audit

Ran an urgent audit of the live GCP environment to find why the platform could not scale - mapping under-provisioned components, database saturation, and the complete absence of monitoring.

Profiling and Distributed Tracing

Enabled application profiling and distributed tracing with Jaeger and Grafana to pinpoint where time and resources were being spent and confirm the real bottlenecks before changing anything.

Resource Right-Sizing

Corrected CPU and memory allocations across the under-provisioned components so services were no longer starved of resources under normal load.

Caching Layer

Introduced a Redis caching layer to serve repeated reads from memory instead of driving heavy SQL queries straight at the database on every request.

Multi-Container Enablement

Worked with the client's developers to patch the application, which had been built to run as a single container, so it operates correctly across multiple concurrent instances.

Database Read-Replica Split

Split the data path into a primary PostgreSQL node for writes and a read-replica for reads, giving granular control over database resource usage under concurrent load.

Kubernetes with Auto-Scaling

Moved the workload onto Kubernetes for automatic horizontal scaling and reworked the GitHub Actions CI/CD to build and deploy to the cluster.

Monitoring and 24/7 On-Call

Stood up Prometheus and Grafana monitoring with alerting and placed the platform under Indeo Solutions 24/7 on-call, replacing the client's manual restart rota entirely.

Conclusion

Fast-shipped infrastructure that ignores scaling and observability trade-offs will stall the moment growth arrives. Right-sizing, caching, a proper read/write data split, auto-scaling on Kubernetes, and real monitoring turned a fragile single-container app into a stable, self-scaling platform, delivered in one focused weekend.

Ready to Transform Your Infrastructure?

Book a free consultation with our team to discuss your DevOps and cloud engineering needs.