-- SQL — read, filter, and join data
-- A very common analyst query: last 30 days of orders
-- with the customer name attached.

SELECT
  o.order_id,
  o.created_at,
  c.name      AS customer,
  o.total
FROM orders o
JOIN customers c
  ON c.id = o.customer_id
WHERE o.created_at >= CURRENT_DATE - INTERVAL '30 days'
  AND o.status = 'completed'
ORDER BY o.created_at DESC
LIMIT 100;

-- Key ideas:
-- - JOIN combines rows across tables on a key
-- - WHERE filters rows before grouping
-- - ORDER BY + LIMIT shape the result set

-- SQL — group by and aggregate
-- Monthly revenue per product category, 2026.

SELECT
  DATE_TRUNC('month', o.created_at) AS month,
  p.category,
  COUNT(DISTINCT o.order_id)        AS orders,
  SUM(oi.qty * oi.unit_price)       AS revenue
FROM orders o
JOIN order_items oi ON oi.order_id = o.id
JOIN products p     ON p.id        = oi.product_id
WHERE o.created_at >= '2026-01-01'
GROUP BY 1, 2
ORDER BY 1, revenue DESC;

-- Key ideas:
-- - GROUP BY collapses rows into groups
-- - Aggregates (COUNT, SUM) produce one value per group
-- - DATE_TRUNC is the analyst's best friend

-- SQL — window functions
-- Rank products by revenue within each category.

WITH product_revenue AS (
  SELECT
    p.category,
    p.name,
    SUM(oi.qty * oi.unit_price) AS revenue
  FROM order_items oi
  JOIN products p ON p.id = oi.product_id
  GROUP BY p.category, p.name
)
SELECT
  category,
  name,
  revenue,
  RANK() OVER (
    PARTITION BY category
    ORDER BY revenue DESC
  ) AS rank_in_category
FROM product_revenue
ORDER BY category, rank_in_category;

-- Window functions are how you compare rows
-- to their peers without collapsing them.
-- They're tested in most analyst interviews.

# Kubernetes — a Deployment running 3 replicas
# File: deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: notes-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: notes-api
  template:
    metadata:
      labels:
        app: notes-api
    spec:
      containers:
        - name: api
          image: myregistry/notes-api:1.0.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "256Mi"

# Key ideas:
# - A Deployment manages a set of identical Pods
# - replicas: 3 means the cluster keeps 3 running
# - resources teach you to think about capacity,
#   which is exactly what production needs

# Kubernetes — a Service that exposes the Deployment
# File: service.yaml
apiVersion: v1
kind: Service
metadata:
  name: notes-api
spec:
  type: ClusterIP
  selector:
    app: notes-api
  ports:
    - port: 80
      targetPort: 8080

# Key ideas:
# - The Service gives the Pods a stable DNS name
# - selector matches the Pods created by the Deployment
# - type can be ClusterIP, NodePort, or LoadBalancer

# For production, pair this with an Ingress controller:
#   - terminates TLS
#   - routes by host/path
#   - centralises auth and rate limiting

# kubectl — the commands you'll use every day
# Apply manifests
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

# See what's running
kubectl get pods
kubectl get deployments
kubectl get svc

# Debug a Pod
kubectl describe pod 
kubectl logs -f deploy/notes-api
kubectl exec -it  -- sh

# Scale and roll out
kubectl scale deploy/notes-api --replicas=5
kubectl rollout status deploy/notes-api
kubectl rollout undo   deploy/notes-api

# Learning tip: spin up minikube or kind locally
# so you can actually run these commands, not
# just read them. K8s is a hands-on skill.

SQL — 30-day beginner plan:
Week 1: SELECT, WHERE, ORDER BY, LIMIT
Week 2: JOINs (INNER, LEFT), aggregates
Week 3: GROUP BY, HAVING, subqueries, CASE
Week 4: Window functions + a real analysis
        on a public dataset (Kaggle / data.gov.in)

Result: Interview-ready for analyst roles.
Total effort: ~30 hours.

No prerequisites — you can start on day one.

Kubernetes — 30-day plan:
(assumes Linux + Docker basics)

Week 1: Install minikube/kind, Pods, YAML basics
Week 2: Deployments, ReplicaSets, Services
Week 3: ConfigMaps, Secrets, Ingress, probes
Week 4: A real app deployed via Helm + CI/CD

Result: Comfortable with basic K8s workflows.

Not recommended without:
- Linux command line confidence
- Having built and run Docker images
- Basic networking (DNS, ports, HTTP)
- One scripting language (Bash or Python)

K8s is a force multiplier — but only after the
foundations are in place.

Data / backend path (recommended order):
1. SQL                   (4-6 weeks)
2. Excel / spreadsheets  (2-3 weeks)
3. Python + Pandas       (4-8 weeks)
4. Power BI or Tableau   (3-4 weeks)
5. (Optional) dbt, cloud warehouse

Roles: Data Analyst, BI Developer, Backend Developer,
       Data Engineer (with more depth)

Kubernetes is usually not required on this path —
though it helps if you work on large data platforms.

DevOps / platform path (recommended order):
1. Linux + bash                (3-4 weeks)
2. Git                          (1 week)
3. Docker                       (2-3 weeks)
4. Kubernetes                   (4-8 weeks)
5. One cloud (AWS / GCP / Azure)(4-8 weeks)
6. Terraform + CI/CD            (3-4 weeks)
7. Observability (Prometheus)   (2 weeks)

Roles: DevOps Engineer, Platform Engineer, SRE,
       Cloud Engineer, Infrastructure Engineer

SQL shows up here too — for debugging data issues,
reading app logs stored in DBs, and verifying deploys.
It's a nice-to-have even on the infra side.