I'm a Backend Developer focused on building modern, maintainable and scalable web applications with Python and FastAPI.

My expertise covers the development of REST APIs, database-driven applications, asynchronous services, authentication systems and containerized applications, with a strong emphasis on automated testing, clean architecture, code quality and maintainability.

I'm particularly interested in backend systems, distributed applications, asynchronous programming and the engineering practices required to build reliable software.

My main backend stack is built around the Python ecosystem:

• Python 3
• FastAPI
• Starlette
• Pydantic
• Uvicorn
• ASGI
• async/await
• asyncio

I build modular backend applications using modern Python development practices, dependency injection and separation of concerns.

Experienced in designing and developing modern HTTP APIs using:

• REST API design
• HTTP
• JSON
• OpenAPI
• Swagger UI
• ReDoc
• Request/response validation
• FastAPI Dependency Injection
• Middleware
• Background Tasks
• Lifespan Events
• CORS
• WebSockets

I focus on building APIs that are well-structured, documented, validated and easy to test and maintain.

My database stack is centered around relational databases and SQL-based backend applications:

• PostgreSQL
• SQLAlchemy
• Alembic
• SQL
• Relational database design
• ORM-based persistence
• Database migrations

I use SQLAlchemy for database access and Alembic for controlled schema evolution and migrations.

Testing is an integral part of my backend development workflow.

• pytest
• pytest-asyncio
• HTTPX
• Factory Boy
• Coverage.py
• unittest.mock
• Unit Testing
• Integration Testing
• End-to-End Testing
• API Testing
• TDD

I focus on building testable applications and using automated tests to verify business logic, API behaviour and integration between application components.

I work with Python's asynchronous programming model and background processing systems.

• async/await
• asyncio
• Asynchronous programming
• Async API endpoints
• Async database operations

• Celery
• Redis
• Celery Workers
• Celery Beat
• Background Tasks

This allows applications to move long-running or scheduled operations away from the main request/response cycle.

Backend security and authentication include:

• OAuth2
• JWT
• Password hashing
• OAuth2PasswordBearer
• Authentication and authorization
• CORS
• HTTP security principles
• Secure API design

I focus on implementing authentication and authorization mechanisms while keeping security concerns separated from application business logic.

I build backend applications using a modular and layered approach.

• Dependency Injection
• Service Layer
• Repository Pattern
• Layered Architecture
• Clean Architecture principles
• Separation of concerns
• Modular FastAPI applications
• Configuration management
• Application Settings

The goal is to keep business logic independent from infrastructure concerns and make applications easier to test, maintain and evolve.

I use containerization and reproducible development environments as part of my backend workflow.

• Docker
• Docker Compose
• Environment variables
• .env configuration

• Uvicorn
• Gunicorn
• Uvicorn Workers
• ASGI deployment

• Git
• GitHub
• venv / virtual environments
• pip
• Pre-commit hooks

I'm particularly interested in the intersection between Backend Engineering and DevOps, including application deployment, infrastructure, observability and reliability.

I follow automated code quality and formatting practices using:

• Ruff
• Black
• isort
• pre-commit
• Static analysis
• Code formatting
• Linting

The objective is to keep the codebase consistent, readable and maintainable.

Although my primary focus is backend development, I can build lightweight server-rendered interfaces for backend applications using:

• HTMX
• Jinja2
• Tailwind CSS
• HTML5
• CSS3

This allows me to develop complete applications while keeping the frontend architecture lightweight and closely integrated with the backend.

A full-stack expense management application built to demonstrate modern Python backend engineering practices.

Python
   │
   └── FastAPI
        │
        ├── Pydantic
        ├── SQLAlchemy
        ├── PostgreSQL
        ├── Alembic
        │
        ├── pytest
        ├── HTTPX
        │
        ├── Celery
        ├── Redis
        │
        ├── JWT / OAuth2
        │
        └── Docker / Docker Compose