Platform engineering, data you can trust

Simple beats clever

• Small surface-area APIs with explicit contracts
• Readable schemas, real names, docstrings
• Single owners, single sources of truth

Measure before tuning

• RED + USE metrics, golden signals
• Structured logs, trace IDs everywhere
• SLOs with burn alerts, not noise

Automate the scary parts

• Blue/green or canary deploys
• Migrations with guards & fallbacks
• Backups tested with restores

Least privilege, always

• Short-lived creds & minimal IAM
• CSP, TLS, dependency hygiene
• Threat modeling as a habit

Modern & accessible

SSR/SPA setups that load fast and are a joy to maintain.

Clean schemas

PostgreSQL first, indexes shaped by queries, safe migrations.

Small & well-documented

OpenAPI/GraphQL, strong typing, rate limits, testable stubs.

Confidence at release

Containers, IaC, rollbacks, and hooks to APM/uptime.

p95 reality

Real-user monitoring and targeted cache strategies.

Practical safety

OWASP-first with CSP, SAST/DAST, and alert drills.

Clean APIs quickly

• Typed serializers & validators
• ViewSets + routers for consistent URLs
• OpenAPI schema export + API docs

Useful back office

• Curated Django Admin for staff workflows
• Role-based access (groups/permissions)
• Row-level checks where needed

Celery + Redis

• Idempotent tasks + retries
• Rate limits + backoff for 3rd parties
• Beat schedules with audit logs

Make queries cheap

• Index-first modeling, pg_stat_statements
• select_related/prefetch_related hygiene
• Per-view caching + CDN edge

Safe by default

• Settings split by env, DJANGO_SECURE_*
• CSP, HTTPS only, HSTS, cookie flags
• Dependency audit, secret rotation

Ship & observe

• 12-factor settings, Docker + Terraform
• Zero-downtime deploys + migrations guard
• APM + SLOs wired to alerts

Serializer + ViewSet + Router

# serializers.py
class ProductIn(serializers.Serializer):
    sku = serializers.CharField(max_length=64)
    price = serializers.DecimalField(max_digits=10, decimal_places=2)

class ProductOut(ProductIn):
    id = serializers.IntegerField(read_only=True)
    in_stock = serializers.BooleanField()

# views.py
class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all().select_related("category")
    serializer_class = ProductOut
    permission_classes = [IsAuthenticated]
    filterset_fields = ["sku", "category_id"]
    search_fields = ["sku"]

# urls.py
router = DefaultRouter()
router.register(r"products", ProductViewSet)
urlpatterns = [path("api/", include(router.urls))]

Celery task (idempotent)

@shared_task(bind=True, autoretry_for=(HTTPError,), retry_backoff=True)
def sync_product(self, product_id):
    p = Product.objects.select_for_update().get(pk=product_id)
    ext = fetch_external(p.sku)  # pure function
    with transaction.atomic():
        Product.objects.filter(pk=p.pk).update(price=ext.price)
        AuditLog.objects.create(kind="sync", ref=p.pk)

Pattern

• Write + deploy code that tolerates BOTH schemas
• Deploy 1: add nullable column/index concurrently
• Backfill in batches (Celery, ETL)
• Deploy 2: switch reads, then writes
• Deploy 3: drop old column

Postgres helpers

-- add index concurrently
CREATE INDEX CONCURRENTLY idx_orders_user_created
ON orders(user_id, created_at);

-- partition by month (example)
CREATE TABLE orders_2025_02 PARTITION OF orders
FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');

API Gateway + BFF

client ──► BFF ──► services
             │        ├─ accounts
             └─ cache  └─ catalog

Event-driven jobs

app ──► queue ──► workers
           │         ├─ email
           └─ retry   └─ reports

Partitioned Postgres

orders_y2025_m02 (
  PARTITION OF orders FOR VALUES
  FROM ('2025-02-01') TO ('2025-03-01')
)

CREATE TABLE payments (
  id BIGSERIAL PRIMARY KEY,
  user_id BIGINT NOT NULL,
  amount NUMERIC(12,2) NOT NULL,
  status TEXT NOT NULL,
  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
) PARTITION BY RANGE (created_at);

type Product { id: ID!, sku: String!, price: Float!, inStock: Boolean! }
type Query   { products(sku: String): [Product]! }

Budget

Budget fraction = 1 − SLO_target. For 99.9% SLO, budget = 0.1% of total requests in the window.

Allowed errors

allowed = traffic_rpm × 60 × 24 × days × budget

Burn rate

burn = (error_rate / 100) / budget. 1.0× means you use exactly your budget pace; 2.0× burns twice as fast.

Time-to-run-out

ttr_hours = allowed / (traffic_rpm × 60 × error_rate_fraction)