Cloud Microservices & Scalable REST API Architecture

The system needed to support both application backend workloads and machine learning inference while remaining scalable, secure, and easy to deploy.

Combining the ML model and backend into a single service would create dependency conflicts, increase deployment complexity, and prevent each workload from scaling independently.

I designed a cloud-native architecture on Google Cloud Platform that separates the ML inference API and Node.js backend into independent Cloud Run services, each with its own CI/CD pipeline. The system integrates Cloud SQL, Cloud Storage, Secret Manager, and Serverless VPC connectivity to support secure and production-ready application workloads.

                         CLOUD-NATIVE ML SYSTEM

 ┌──────────────────── CI/CD — ML SERVICE ──────────────────────┐

 [ML Engineer]
       │
       ▼
 [Google Colab]
 Model Training
       │
       ▼
    [GitHub]
       │
       ▼
 [Cloud Build]
       │
       ▼
 [Container Registry]
       │
       ▼
 [Cloud Run]
   ML API
       ▲
       │ REST / HTTP
       │
 ──────┼─────────────────────────────────────────────────────────
       │
       │
 [Backend API]
 [Cloud Run]
       │
       ├────────► [ML API]
       │          Model Inference
       │
       ├────────► [Cloud Storage]
       │          Object / File Storage
       │
       ├────────► [Secret Manager]
       │          Credentials / Secrets
       │
       ▼
 [Serverless VPC Connector]
       │
       ▼
    [Cloud SQL]
 Application Database
       ▲
       │
       │ HTTPS / REST
       │
 [Mobile Client]


 ┌────────────── CI/CD — BACKEND SERVICE ───────────────────────┐

 [Backend Developer]
       │
       ▼
    [GitHub]
       │
       ▼
 [Cloud Build]
       │
       ▼
 [Container Registry]
       │
       ▼
 [Cloud Run Backend API]

• Independent Service Architecture: Separated the Node.js backend and machine learning inference service into independent Cloud Run deployments, allowing each workload to scale, update, and fail independently.
• Automated CI/CD Pipeline: GitHub pushes automatically trigger Google Cloud Build to build container images, publish them to Container Registry, and deploy new revisions to Cloud Run.
• Containerized Deployment: Packaged both backend and ML services as Docker containers to ensure consistent environments across development and production.
• Serverless Compute: Used Google Cloud Run to provide auto-scaling, managed infrastructure, and on-demand execution without maintaining dedicated application servers.
• Dedicated ML Inference API: Exposed the machine learning model as an independent HTTP API, keeping ML-specific dependencies isolated from the main application backend.
• Secure Secret Management: Stored database credentials, API keys, and environment secrets using Google Cloud Secret Manager instead of embedding sensitive values in source code.
• Private Database Connectivity: Connected Cloud Run to Cloud SQL through a Serverless VPC Connector to provide controlled access to application data.
• Object Storage Integration: Used Google Cloud Storage for application files and assets that should not be stored directly inside the relational database.
• Mobile-to-Cloud API Integration: Designed the backend as the primary API layer for the mobile client while coordinating database, storage, and machine learning inference requests.
• Independent Deployment Lifecycle: Backend changes and ML model changes can be released independently, reducing deployment risk and avoiding unnecessary full-system redeployment.