Skip to case study
All projects
Selected work02 / 04 · 2 min read

Project case study ↘

FastAPI Ecosystem Lab

One backend, multiple clients, explicit boundaries.

This project explores how authentication, account management and item workflows fit together when application logic stays separate from databases, caching and external services.

Conceptual system sketch · not a product screenshot
My role
Developer · personal learning project
Context
Backend architecture and full stack integration practice
Project status
Evolving backend · Next.js frontend in progress
Period
Mar 2026 – Present

The challenge

Start with the problem.

The problem

A backend serving different clients needs consistent rules for authentication, ownership and data access. Mixing those rules directly into routes makes them harder to follow as integrations grow.

The approach

Organize authentication, users and items into feature modules. Put application workflows behind API routes and connect persistence, caching, media and events through dedicated adapters.

My contribution

From idea to implementation.

01 /

Authentication and account workflows

Connected a versioned API with authentication, token refresh, logout and account management.

02 /

Ownership-aware item operations

Implemented item workflows that resolve the authorized owner before reading or changing records, alongside cache-aside list reads.

03 /

Adapters and client integration

Composed SQLAlchemy, Redis, Cloudinary and server-sent event adapters, with a Streamlit client and an ongoing Next.js frontend.

Architecture

How the pieces connect.

A modular backend in one learning monorepo. Presentation calls application workflows; domain rules and ports separate those workflows from infrastructure.

  1. Clients and API

    A Streamlit client consumes the versioned FastAPI API. A separate Next.js frontend is in progress.

  2. Application workflows

    Auth, users and items modules coordinate operations and authorization through use cases.

  3. Domain and ports

    Application boundaries describe the persistence and service behavior each workflow needs.

  4. Infrastructure adapters

    Dependency composition connects SQLAlchemy persistence, Redis cache, Cloudinary media and SSE events.

Tools of the build

  • Python
  • FastAPI
  • SQLAlchemy
  • PostgreSQL
  • Redis
  • Streamlit
  • Next.js

Decisions

The thinking behind the code.

01

Organize by feature and responsibility

Keep auth, users and items distinct, with presentation, application, domain and infrastructure responsibilities.

Why this choice / trade-off

More modules and explicit wiring in exchange for clearer places to change a workflow or integration.

02

Use ports for external services

Compose concrete persistence, cache, media and event adapters at the dependency boundary.

Why this choice / trade-off

Adapter contracts add setup work, while keeping service-specific details out of application workflows.

03

Cache item-list reads

Use a cache-aside path for item lists after resolving the caller’s permitted scope.

Why this choice / trade-off

Caching introduces invalidation and consistency concerns alongside the database read path.

The result

What the project delivers.

  • A versioned API for authentication, accounts and ownership-aware item operations.

  • Application workflows connected to persistence, caching, media uploads and SSE adapters.

  • An implemented Streamlit client, with the Next.js frontend continuing in the same monorepo.

What I learned

Separating application rules from infrastructure makes dependencies visible. The project is also a practical setting for studying authorization scope, cache consistency and how different clients share one API.

Keep exploring

Let’s build something useful.

Get in touch