How Does Python Programming Work in Real Companies Today?

A day on a Python team:
09:00 — Stand-up: what shipped, what is blocked
09:30 — Read the ticket and the existing code
10:00 — Write the failing test first
10:30 — Implement the smallest change that passes
11:30 — Run the full suite locally, push a branch
12:00 — Open a pull request with a clear description
13:00 — Lunch
14:00 — Review a teammate's pull request
15:00 — Address review comments, push fixes
16:00 — Watch CI go green, merge, verify the deploy
16:30 — Check dashboards and error tracking
17:00 — Update the changelog or docs

Before you write code:
□ Do I understand the acceptance criteria?
□ Is there an existing module I should extend?
□ Do I need a migration or a config change?

Before you open the PR:
□ A test fails without my change and passes with it
□ ruff and mypy are clean
□ No secrets, no print() debugging left behind
□ PR description explains the why, not just the what

Before you merge:
□ At least one approving review
□ CI green on the latest commit
□ Feature flag in place if the change is risky

After the deploy:
□ Error rate and latency look normal
□ Logs show the new code path being taken
□ Rollback plan is written down

my-service/
├── pyproject.toml         # deps, tool config, metadata
├── uv.lock                # pinned, reproducible installs
├── Dockerfile
├── src/
│   └── my_service/
│       ├── __init__.py
│       ├── api/           # FastAPI routers
│       ├── core/          # settings, logging, config
│       ├── models/        # pydantic + ORM models
│       └── services/      # business logic
├── tests/
│   ├── unit/
│   └── integration/
└── .github/workflows/ci.yml

name: ci
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install uv && uv sync --frozen
      - run: uv run ruff check .
      - run: uv run mypy src
      - run: uv run pytest -q --cov=src
      - run: docker build -t app:${{ github.sha }} .

from datetime import datetime
from airflow import DAG
from airflow.operators.python import PythonOperator

def extract(**ctx):
    ...

def transform(**ctx):
    ...

def load(**ctx):
    ...

with DAG(
    "orders_daily",
    start_date=datetime(2026, 1, 1),
    schedule="0 2 * * *",
    catchup=False,
    default_args={"retries": 2},
) as dag:
    t1 = PythonOperator(task_id="extract", python_callable=extract)
    t2 = PythonOperator(task_id="transform", python_callable=transform)
    t3 = PythonOperator(task_id="load", python_callable=load)

    t1 >> t2 >> t3

A notebook is a lab. Production needs a pipeline.

□ Move logic into a .py module, not a .ipynb
□ Parameterise paths and dates — no hardcoded values
□ Add tests for the transformation functions
□ Make the job idempotent (safe to re-run)
□ Log row counts in and out of every step
□ Fail loudly on bad data, not silently
□ Schedule it and alert on failure
□ Document who owns it and what breaks it