How Do You Discuss Python Projects?

Use a fixed structure so the interviewer can follow it, and keep it to about two minutes before they interrupt.

Start with the problem, not the stack. What was the system for, who used it, and what was failing or missing — for example a manual reporting process that took a day to produce a spreadsheet. Then the shape of the solution: a FastAPI service that reads from Postgres and writes scheduled reports to S3, with a Celery worker for the scheduled jobs. Then your part in it, specifically. Interviewers are listening hardest here, and vagueness is the main thing that loses candidates.

Then pick one decision and go one level deep. Not a list of everything you built, but one meaningful trade-off: why a background worker instead of running the job in the request, why you used a dataclass rather than a dict, why you cached in Redis rather than in-process. Explain the alternative you rejected and why. That single story demonstrates judgement better than ten features.

Finally, be honest about what went wrong. Every real project has something that broke, something you would do differently, or a piece you inherited and rewrote. Being able to describe a mistake and what you changed about it is a strong signal, because it shows you have been the kind of engineer who reflects on the work.

Being able to talk about the layout of your code is part of the discussion.

import os
import sys
import tempfile

root = tempfile.mkdtemp()
package = os.path.join(root, "billing")
os.makedirs(package)

with open(os.path.join(package, "__init__.py"), "w", encoding="utf-8") as handle:
    handle.write("from .invoice import Invoice\n")

with open(os.path.join(package, "invoice.py"), "w", encoding="utf-8") as handle:
    handle.write(
        "class Invoice:\n"
        "    def __init__(self, lines):\n"
        "        self.lines = list(lines)\n"
        "\n"
        "    def total(self):\n"
        "        return sum(price * qty for price, qty in self.lines)\n"
    )

sys.path.insert(0, root)

from billing import Invoice

invoice = Invoice([(9.99, 2), (4.5, 1)])
print(round(invoice.total(), 2))     # 24.48

The script builds a package directory with an __init__.py that re-exports the Invoice class, and an invoice module that holds the class itself. The total comes to 24.48 after rounding, which is two units at 9.99 plus one at 4.50.

The layout demonstrates the conventions you would want to talk about. A package per domain, an __init__.py that defines the public surface so callers import from billing rather than from billing.invoice, and one module per concern so the file stays readable. The relative import inside __init__.py keeps the package self-contained.

Two points to make when discussing it. The class takes a list of lines and stores a copy of it, so a caller mutating their list afterwards cannot change the invoice behind its back. And total is a method rather than a stored attribute, because it is derived data — recomputing it is always correct, whereas caching it would need invalidation logic.