Python developer

Joseph Anderson

I build APIs, data tools, and automation in Python. Clear structure, tested behavior, and software another person can maintain.

See the work Call +1 (334) 820-4630

Stanford University · Foundations in Computer Science · 2017

joseph@anderson — python interactive

01 — About

Software that stays calm in production.

Python is my main language. I use it for services, for data, and for the scripts that should have become services. I care about typed boundaries, small modules, and tests that explain the behavior when someone returns six months later.

I studied computer science at Stanford University and completed the Foundations in Computer Science graduate certificate in 2017, through the Department of Computer Science and the Stanford Engineering Center for Global & Online Education.

Focus: Backend and data
Language: Python
Study: Stanford University
Phone: +1 (334) 820-4630

Wooden shelves of bound books with red, gold, and dark spines. — The stacks, where the record lives.

Practice

The stack I reach for.

Python

Types, the standard library, async where it earns its place, and packaging that another machine can install. The language is the product, not a layer I hide.

def ship(change: Change) -> None: ...

Services

FastAPI, Django, and Flask. HTTP with explicit schemas, predictable errors, and an OpenAPI contract.

FastAPI
Django
Flask
Pydantic

Data

PostgreSQL for the record. SQLAlchemy for the model. Pandas and NumPy when the work is a table, not a route.

PostgreSQL
SQLAlchemy
Pandas
NumPy

Delivery

pytest around the behavior that matters. Docker so the runtime is not a memory. Git, Linux, and a short CI path from branch to something runnable.

pytest
Docker
Redis
Linux
Git

02 — Selected studies

Three shapes of Python work.

Studies of the systems I like to take from a blank repository to something another developer can run. Each one is a way of building, not a client claim.

Dark server cabinets threaded with lit cables.

Study 01 · Services

Signal Desk

An async ingestion service. It accepts webhooks, checks the payload against a schema, and hands the event to a worker. The route stays thin. The contract is the part other teams can rely on.

FastAPI
Pydantic
PostgreSQL
Redis

signal_desk.pysketch

# accept, validate, hand off
class EventIn(BaseModel):
    source: str
    kind: Literal["created", "updated", "failed"]
    payload: dict[str, Any]

@router.post("/events", status_code=202)
async def ingest(event: EventIn, bus: Bus = Depends(get_bus)):
    await bus.publish(event.kind, event.model_dump())
    return {"accepted": True}

Study 02 · Data

Clearwater

A reconciliation pipeline for messy exports. Two tables enter, a shared key lines them up, and the rows that fail to match become an exception report a person can read. The goal is an audit trail, not a clever one-liner.

Pandas
NumPy
PostgreSQL
pytest

clearwater.pysketch

def reconcile(left: pd.DataFrame, right: pd.DataFrame) -> pd.DataFrame:
    keys = ["account", "posted_on", "amount"]
    merged = left.merge(
        right, on=keys, how="outer", indicator=True
    )
    exceptions = merged.loc[merged["_merge"] != "both"]
    return exceptions.reset_index(drop=True)

Study 03 · Tools

Workshop

Internal tools in Django: authentication, a small set of workflows, and a scheduled job that replaces a folder of one-off scripts. The admin is the interface. The task queue is how the slow work leaves the request.

Django
Celery
PostgreSQL
Docker

jobs.pysketch

@shared_task
def close_stale_jobs():
    cutoff = timezone.now() - timedelta(days=14)
    stale = Job.objects.filter(
        status="open",
        updated_at__lt=cutoff,
    )
    return stale.update(status="closed", closed_by="system")

01
Name the boundary

Types, schemas, and function signatures before the clever part. A boundary you can point at is a boundary you can test.
02
Make failure obvious

Errors, logs, and tests written for the next person. A stack trace should explain itself without a meeting.
03
Leave it smaller

Refactor toward the next change. If a module needs a tour guide, it is not finished.

03 — Study

Stanford University

Foundations in Computer Science

Graduate Certificate · 2017

Awarded by the Department of Computer Science and the Stanford Engineering Center for Global & Online Education, after completion of the certificate requirements.

04 — Contact

Tell me about the Python work.

APIs, data pipelines, and the automation that keeps a product running. Call, or copy a note and send it to this number.

+1 (334) 820-4630

Call Joseph