How Retail Companies Use Cloud Computing to Grow Faster

# Event-driven inventory update
# The pattern that keeps stock levels accurate across stores,
# warehouses, and the online store in real time.

import json
import boto3
from decimal import Decimal

# Every stock movement publishes an event to a queue.
# A Lambda (or similar function) processes the event and updates
# the central inventory table.

dynamodb = boto3.resource("dynamodb")
inventory = dynamodb.Table("inventory")
sqs = boto3.client("sqs")


def handle_stock_event(event, context):
    """Called by SQS for each stock movement event."""
    for record in event["Records"]:
        payload = json.loads(record["body"])

        sku = payload["sku"]
        delta = Decimal(str(payload["delta"]))  # +/- change
        store_id = payload["store_id"]

        # Atomic increment — safe under concurrent updates
        inventory.update_item(
            Key={"sku": sku, "store_id": store_id},
            UpdateExpression="ADD qty :d",
            ExpressionAttributeValues={":d": delta},
            ReturnValues="UPDATED_NEW",
        )

    return {"statusCode": 200}

# What this enables:
# - Any channel (web, store, warehouse) publishes a stock event
# - The inventory table is updated within seconds
# - The online store and store apps both see the same number
# - No stale data, no overselling, no "in stock online but sold out
#   in store" confusion
#
# This is the entire omnichannel promise, built on one pattern.

-- Personalised recommendations query
-- Usually run nightly to populate a rec table, then served in real time.

-- Find each customer's most-purchased categories in the last 90 days
WITH customer_categories AS (
  SELECT
    o.customer_id,
    p.category,
    COUNT(*) AS purchases,
    SUM(o.total) AS spend
  FROM orders o
  JOIN order_items oi ON oi.order_id = o.id
  JOIN products p ON p.id = oi.product_id
  WHERE o.order_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAY)
  GROUP BY 1, 2
),

-- Rank categories per customer
ranked AS (
  SELECT
    customer_id,
    category,
    purchases,
    spend,
    ROW_NUMBER() OVER (
      PARTITION BY customer_id
      ORDER BY purchases DESC, spend DESC
    ) AS cat_rank
  FROM customer_categories
)

-- Get top 3 categories per customer
SELECT
  customer_id,
  ARRAY_AGG(category ORDER BY cat_rank) AS top_categories
FROM ranked
WHERE cat_rank <= 3
GROUP BY 1;

-- What this enables:
-- - Each customer gets a personalised category feed
-- - Marketing can segment by top category
-- - Recommendation service enriches this with product-level recs
-- - Runs nightly on a data warehouse (Snowflake, BigQuery, Redshift)
--
-- This is the base layer of "personalisation at scale" —
-- the same data that powers email campaigns, homepage carousels,
-- and push notifications.

# Auto-scaling config for peak sales
# What lets a retail storefront handle Diwali traffic without
# paying for peak capacity all year.

# Terraform (or CloudFormation) config for auto-scaling
resource "aws_autoscaling_group" "storefront" {
  name                = "storefront-asg"
  vpc_zone_identifier = ["subnet-a", "subnet-b", "subnet-c"]
  target_group_arns   = [aws_lb_target_group.storefront.arn]

  # Small baseline — cheap when idle
  min_size         = 2
  desired_capacity = 4
  max_size         = 200

  launch_template {
    id      = aws_launch_template.storefront.id
    version = "$Latest"
  }

  tag {
    key                 = "Name"
    value               = "storefront"
    propagate_at_launch = true
  }
}

# Scale on CPU — add instances when load goes high
resource "aws_autoscaling_policy" "cpu_high" {
  name                   = "cpu-high"
  autoscaling_group_name = aws_autoscaling_group.storefront.name
  policy_type            = "TargetTrackingScaling"

  target_tracking_configuration {
    predefined_metric_specification {
      predefined_metric_type = "ASGAverageCPUUtilization"
    }
    target_value = 60.0
  }
}

# What this enables:
# - Normal day: 2–4 instances (cheap)
# - Diwali sale starts: 200 instances spin up within minutes
# - Sale ends: back to 2 instances
# - No manual intervention, no pre-buying servers
#
# The same scaling pattern powers the storefront, the checkout API,
# and the personalisation service — all coordinated so the whole
# stack scales together under load.
#
# This is why "cloud is cheaper" is only half the story.
# The other half is: cloud is the only way to be ready for a
# 100x traffic spike without paying for it 365 days a year.