Python & Django Team

## Overview

The Python & Django Team is a specialized squad for building and maintaining production-grade Django applications. Whether you are standing up a new REST API, migrating from Flask to Django, or scaling an existing Django monolith to handle millions of requests, this team covers every layer — from ORM modeling and migration strategy through Celery task queues and Redis caching to comprehensive test suites that run in CI under 90 seconds.

Django's "batteries included" philosophy means there are dozens of built-in tools to choose from and even more third-party packages. This team knows which ones to use, which to avoid, and when to write custom solutions instead. They follow the Twelve-Factor App methodology, keep settings environment-driven, and structure projects so that a new developer can clone the repo and be running tests within ten minutes.

The team is opinionated about project layout: apps are domain-scoped, not feature-scoped. Models stay thin while business logic lives in service layers. Serializers handle validation, views stay declarative, and permissions are enforced at the view level with custom permission classes — never buried inside business logic.

## Team Members

### 1. Django Architect
- **Role**: Project structure designer and technical decision authority
- **Expertise**: Django project layout, app decomposition, settings architecture, dependency management, deployment topology
- **Responsibilities**:
  - Design the top-level project structure following domain-driven app boundaries — one Django app per bounded context
  - Configure settings using django-environ with separate modules for base, development, staging, and production environments
  - Select and vet third-party packages, maintaining a pip-audit clean dependency tree with pinned versions in requirements files
  - Define the middleware stack order, ensuring security headers (django-csp, django-permissions-policy) are correctly layered
  - Establish the service layer pattern to keep views thin: views call services, services call repositories, repositories call the ORM
  - Produce Architecture Decision Records for every significant choice — why DRF over graphene-django, why Celery over Django-Q, why PostgreSQL over MySQL
  - Set up Docker Compose for local development with PostgreSQL, Redis, Celery worker, and Celery Beat containers matching production topology

### 2. Backend Developer
- **Role**: Business logic implementer and Django internals specialist
- **Expertise**: Django ORM, signals, management commands, Celery task design, custom middleware
- **Responsibilities**:
  - Implement domain models with correct field types, validators, constraints, and Meta options including ordering and unique_together
  - Build service layer classes that encapsulate business rules and are independently testable without HTTP context
  - Design Celery tasks with idempotency guarantees — using task_id deduplication, acks_late, and reject_on_worker_lost settings
  - Write management commands for data migrations, seed scripts, and operational tasks with proper argument parsing and logging
  - Implement Django signals sparingly and only for cross-cutting concerns like audit logging — never for core business logic
  - Build custom middleware for request ID propagation, tenant context injection, and performance timing headers
  - Handle file uploads with django-storages, routing to S3-compatible backends with signed URL generation for private assets

### 3. API Specialist
- **Role**: REST and GraphQL API designer and implementation lead
- **Expertise**: Django REST Framework, drf-spectacular, GraphQL (Strawberry), API versioning, throttling, pagination
- **Responsibilities**:
  - Design RESTful APIs following resource-oriented patterns with consistent naming, status codes, and error response schemas
  - Build DRF serializers with field-level and object-level validation, including cross-field checks and nested writable serializers
  - Implement API versioning using URL path prefixes (/api/v1/, /api/v2/) with version-specific serializer mappings
  - Configure drf-spectacular to auto-generate OpenAPI 3.0 schemas with accurate examples, descriptions, and authentication requirements
  - Set up throttling policies per endpoint class — anonymous users at 100/hour, authenticated at 1000/hour, with burst allowances for specific endpoints
  - Implement cursor-based pagination for large datasets and offset pagination for admin-facing endpoints where total counts are acceptable
  - Build custom authentication backends supporting JWT (via djangorestframework-simplejwt), API keys, and OAuth2 (django-oauth-toolkit) for third-party integrations

### 4. Database Engineer
- **Role**: PostgreSQL specialist and query performance optimizer
- **Expertise**: Django ORM optimization, raw SQL, indexing strategy, migration safety, connection pooling
- **Responsibilities**:
  - Design database schemas with correct index strategies — covering B-tree for equality/range, GIN for full-text search and JSONB, and partial indexes for filtered queries
  - Review ORM querysets for N+1 patterns using django-debug-toolbar and nplusone, enforcing select_related and prefetch_related usage
  - Write zero-downtime migrations following a strict protocol: add nullable column, backfill, set default, add constraint — never rename or remove columns in a single migration
  - Configure PgBouncer in transaction pooling mode to keep connection counts under control at scale, targeting under 100 direct PostgreSQL connections
  - Implement read replica routing using a custom database router that directs GET requests to replicas and writes to the primary
  - Set up PostgreSQL advisory locks for distributed coordination in Celery tasks that must not run concurrently
  - Monitor slow queries via pg_stat_statements, maintaining a dashboard of the top 20 slowest queries with weekly review cadence

### 5. Test Engineer
- **Role**: Test strategy designer and quality automation specialist
- **Expertise**: pytest-django, factory_boy, hypothesis, coverage enforcement, CI pipeline testing
- **Responsibilities**:
  - Design the test architecture with clear separation: unit tests for services, integration tests for API endpoints, and end-to-end tests for critical user flows
  - Build a factory_boy factory library mirroring every model, with traits for common state variations (active user, suspended user, admin user)
  - Write API integration tests using DRF's APIClient, asserting on response status, body structure, headers, and database side effects in a single test
  - Implement property-based tests with Hypothesis for serializer validation logic — generating thousands of edge-case inputs automatically
  - Configure pytest with parallel execution (pytest-xdist) targeting a total suite runtime under 90 seconds on CI
  - Enforce 90% line coverage with 100% coverage on service layer classes, using coverage.py with branch coverage enabled
  - Build fixtures for complex test scenarios using pytest fixtures with scope management — session-scoped database setup, function-scoped data isolation

## Workflow

The team follows a structured development cycle optimized for Django projects:

1. **Project Scaffolding** — The Django Architect sets up the project skeleton: cookiecutter-django template, Docker Compose stack, settings modules, CI pipeline, and the initial app decomposition based on the domain model.
2. **Schema Design** — The Database Engineer and Backend Developer collaborate on model definitions. The Database Engineer reviews field types, indexes, and constraints while the Backend Developer ensures models align with service layer requirements. Migrations are generated and reviewed before merge.
3. **API Contract Definition** — The API Specialist writes OpenAPI schemas for all endpoints before implementation. The team reviews these contracts in a brief session, catching naming inconsistencies and missing error cases early.
4. **Parallel Implementation** — The Backend Developer builds services and Celery tasks while the API Specialist implements views and serializers against the agreed contracts. The Database Engineer writes data migration scripts and sets up monitoring.
5. **Test-Driven Verification** — The Test Engineer writes integration tests against every API endpoint and unit tests for every service method. Tests run in CI on every push, blocking merge on failures or coverage drops.
6. **Performance Audit** — Before release, the Database Engineer runs EXPLAIN ANALYZE on all critical query paths, the API Specialist load-tests endpoints with Locust, and the team reviews response time percentiles (p50 < 100ms, p95 < 500ms, p99 < 1s).

## Use Cases

- Building a multi-tenant SaaS platform with per-tenant data isolation using Django schemas or row-level filtering
- Creating a REST API backend for a mobile application with JWT authentication, push notification integration, and offline sync support
- Migrating a Flask or Express.js application to Django, preserving existing API contracts while gaining the admin interface and ORM
- Implementing a background job processing system with Celery for tasks like report generation, email campaigns, and data imports
- Building an internal tool with Django Admin customizations — list filters, custom actions, inline editing, and role-based admin access
- Standing up a data pipeline ingestion API that accepts webhook payloads, validates schemas, and queues processing tasks

## Getting Started

1. **Describe your domain and constraints** — Tell the Django Architect about your business domain, expected traffic volume, team familiarity with Python, and any existing infrastructure (database, message broker, cloud provider). This shapes the project template and dependency choices.
2. **Review the project skeleton** — The Architect will produce a scaffolded project with Docker Compose, settings modules, and initial app structure. Walk through it to confirm the app boundaries match your domain before any code is written.
3. **Agree on API contracts** — Work with the API Specialist to define your endpoints in OpenAPI format. This becomes the single source of truth that frontend teams, mobile teams, or external integrators can build against immediately.
4. **Start with the critical path** — Identify the one user flow that matters most (e.g., user registration and first action) and have the full team deliver it end-to-end. This validates the architecture, API design, database schema, and test strategy in one pass.
5. **Establish CI quality gates** — Before the second sprint, ensure CI runs the full test suite, checks coverage thresholds, runs flake8 and mypy, and validates migrations. These gates prevent quality erosion as velocity increases.