Unifying Online and In-Store Retail Experiences Using Cloud Technologies

Unifying Online and In-Store Retail Experiences Using Cloud Technologies

Building a scalable, cloud-based retail platform with microservices

Context

Modern retailers operate across physical stores and online platforms, but these systems often function independently. This separation creates problems such as inconsistent pricing, inaccurate inventory, and fragmented customer experiences.

This blog explains a cloud-based microservices project designed to unify online and in-store retail systems, providing real-time inventory visibility, consistent pricing, and data-driven decision-making.

Project Overview

Project Title

Unifying Online and In-Store Retail Experiences Using Cloud Technologies

Business Problem

Large retail organizations typically manage:

• Physical (offline) stores
• Online (e-commerce) platforms

When these systems are not integrated, it leads to:

• Different prices across channels
• Inconsistent promotions
• Incorrect inventory availability

These issues reduce customer trust and result in lost sales opportunities.

Project Objectives

The main goals of this project are:

• Integrate online and in-store retail systems
• Provide real-time inventory visibility
• Maintain consistent pricing and promotions
• Build a scalable and reliable cloud architecture
• Enable analytics and demand forecasting

Technology Stack

System Architecture Overview

Request Flow

1. A customer opens the e-commerce website
2. Static content is served via Cloud CDN
3. Dynamic requests are routed to GKE microservices
4. APIs are secured and managed using Apigee
5. Inventory data is fetched from Cloud Spanner
6. Sales data is streamed to BigQuery for analytics

Architecture Diagram

flowchart LR
    User[Customer]
    CDN[Cloud CDN]
    GKE[GKE Microservices]
    Apigee[Apigee API Gateway]
    Spanner[Cloud Spanner]
    BigQuery[BigQuery Analytics]

    User --> CDN
    CDN --> GKE
    GKE --> Apigee
    Apigee --> Spanner
    GKE --> BigQuery

Step-by-Step Implementation

Step 1: Frontend Delivery with Cloud CDN

Implementation

• Static assets such as HTML, CSS, JavaScript, and images are cached using Cloud CDN.

Benefits

• Faster page load times
• Reduced backend load
• Improved SEO performance

Cloud CDN caches static content and serves users from the nearest edge location.

Step 2: Microservices Deployment on GKE

Product Service Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      containers:
      - name: product-service
        image: gcr.io/my-project/product-service:v1
        ports:
        - containerPort: 8080

Service Configuration

apiVersion: v1
kind: Service
metadata:
  name: product-service
spec:
  selector:
    app: product-service
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

• Deployment manages application pods
• Service exposes the application to external traffic

Step 3: Auto-Scaling with Horizontal Pod Autoscaler

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: product-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: product-service
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60

This configuration automatically scales services during high-traffic periods such as sales or festivals.

Step 4: API Management Using Apigee

Inventory API Endpoint

GET /api/inventory/{productId}

Sample API Response

{
  "productId": "P123",
  "storeId": "STORE45",
  "availableQuantity": 28,
  "price": 999
}

Apigee provides:

• API security
• Rate limiting
• Traffic monitoring

Step 5: Inventory Microservice (Spring Boot Example)

@RestController
@RequestMapping("/inventory")
public class InventoryController {

    @GetMapping("/{productId}")
    public Inventory getInventory(@PathVariable String productId) {
        return new Inventory(productId, "STORE45", 28, 999);
    }
}

This simple implementation is ideal for Spring Boot beginners and demonstrates RESTful service design.

Step 6: Cloud Spanner Database Schema

CREATE TABLE Inventory (
    product_id STRING(36) NOT NULL,
    store_id STRING(36),
    quantity INT64,
    price FLOAT64
) PRIMARY KEY (product_id);

This table stores real-time inventory data across all retail locations.

Step 7: BigQuery Analytics

Sales Data Table

CREATE TABLE retail_sales (
    order_id STRING,
    product_id STRING,
    quantity INT64,
    total_price FLOAT64,
    order_time TIMESTAMP
);

Analytics Query

SELECT product_id, SUM(quantity) AS total_sold
FROM retail_sales
GROUP BY product_id
ORDER BY total_sold DESC;

Use Cases

• Demand forecasting
• Supply chain optimization
• Sales trend analysis

Project Folder Structure

retail-cloud-project/
│── README.md
│── architecture.md
│── kubernetes/
│   ├── deployment.yaml
│   ├── service.yaml
│   └── hpa.yaml
│── api/
│   └── inventory-api.md
│── analytics/
│   └── bigquery.sql

Key Advantages

• Unified online and offline retail experience
• Real-time inventory accuracy
• High scalability and reliability
• Faster application performance
• Data-driven business decisions

Real-World Applications

• Supermarkets
• Shopping malls
• Omni-channel retail platforms
• Large-scale e-commerce businesses

Future Enhancements

• AI-based product recommendations
• Mobile application integration
• Real-time customer personalization
• Serverless checkout services

This project demonstrates how cloud technologies and microservices can unify online and in-store retail systems into a single, scalable platform. By integrating real-time databases, API management, and analytics, retailers can significantly improve customer experience, operational efficiency, and business growth.