SQL or PyTorch First: What Beginners Should Pick

-- SQL: the foundation of every data career
-- A realistic analyst query — cohort retention analysis

WITH customer_cohorts AS (
    -- Assign each customer to a cohort based on first order
    SELECT
        customer_id,
        DATE_TRUNC('month', MIN(order_date)) AS cohort_month
    FROM orders
    GROUP BY customer_id
),

monthly_activity AS (
    -- Track activity by month per customer
    SELECT
        o.customer_id,
        c.cohort_month,
        DATE_TRUNC('month', o.order_date) AS activity_month,
        COUNT(DISTINCT o.id) AS orders,
        SUM(o.total_amount) AS revenue
    FROM orders o
    JOIN customer_cohorts c USING (customer_id)
    GROUP BY 1, 2, 3
),

retention AS (
    -- Compute retention percentage per cohort per month
    SELECT
        cohort_month,
        activity_month,
        DATEDIFF('month', cohort_month, activity_month) AS month_number,
        COUNT(DISTINCT customer_id) AS active_customers,
        FIRST_VALUE(COUNT(DISTINCT customer_id))
            OVER (PARTITION BY cohort_month ORDER BY activity_month) AS cohort_size
    FROM monthly_activity
    GROUP BY 1, 2, 3
)

SELECT
    cohort_month,
    month_number,
    active_customers,
    ROUND(100.0 * active_customers / cohort_size, 2) AS retention_pct
FROM retention
ORDER BY cohort_month, month_number;

-- Skills tested in interviews: CTEs, window functions, cohort logic,
-- aggregations, joins, business thinking.
-- This is what 90% of data analyst interviews actually test.

-- And here's the beautiful thing: this same skill transfers to
-- data engineering, data science, and analytics engineering.

# PyTorch: a specialised ML skill
# Training a neural network — the actual code you write

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 1. Define a small CNN for image classification
class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(64 * 8 * 8, 128)
        self.fc2 = nn.Linear(128, num_classes)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = x.view(x.size(0), -1)
        x = self.relu(self.fc1(x))
        x = self.dropout(x)
        return self.fc2(x)

# 2. Setup
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = SimpleCNN(num_classes=10).to(device)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# 3. Training loop
for epoch in range(10):
    running_loss = 0.0
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = loss_fn(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    print(f"Epoch {epoch+1}: loss={running_loss/len(train_loader):.4f}")

# Skills needed to understand this code:
# - Python fluency
# - Neural network concepts (forward pass, backprop)
# - Loss functions, optimizers, gradient descent
# - Understanding tensors, device placement, training loops
# - Math (linear algebra for matrix operations, calculus for gradients)

# This is a 10-month-plus journey for a complete beginner.
# SQL is a 2–3 month journey.