DEV Community: prasanna Kumar

Project Experience 2021-2023

prasanna Kumar — Fri, 10 Apr 2026 01:39:33 +0000

During my tenure at Zensar (April, 2021 : April 2023), I led the end‑to‑end development of a critical monitoring solution for Cisco, focused on tracking service health across SD‑WAN devices. The project was built on a robust backend stack: Django, Django REST Framework, and Celery for asynchronous task processing.

I took full ownership of the backend systems and the overall delivery, which included:

Architecture & development – designing the entire backend architecture, writing RESTful APIs, and integrating them seamlessly with the frontend.

Database & operations – managing all database migrations, ensuring data consistency, and implementing authentication and authorization layers.

Environment management – configuring dedicated development, QA, and production environments with environment‑specific settings, SSL certificates, host mappings, and URL routing.

DevOps & deployments – writing and managing builds, pushing and pulling container images, and handling complete deployments across all environments.

Team leadership – leading the team technically, coordinating frontend‑backend integration, and ensuring timely delivery of high‑quality code.

project was fun. – from writing build scripts to deploying on infrastructure(Cisco isolated Linux tools/server), configuring SSL termination for secure communication, and maintaining zero‑downtime updates across environments. This project sharpened my expertise in full‑stack Django development, distributed task processing with Celery, secure multi‑environment configuration, and team leadership in an enterprise setting.

Senior Software Engineer — Zensar Technologies (Cisco RAIDN Project)

• Designed and developed scalable REST APIs using Python and Django, supporting enterprise-level network analytics platform
• Architected and deployed containerized applications using Docker, improving deployment consistency and reducing environment issues
• Built and optimized PostgreSQL queries, improving API response times and system performance
• Designed CI/CD pipelines using Jenkins, enabling automated builds and zero-downtime deployments
• Managed Linux-based production systems with Nginx and Gunicorn, ensuring high availability and reliability
• Implemented background processing using Celery and Redis for asynchronous task handling
• Led deployment and environment setup across staging and production systems
• Collaborated with cross-functional teams and mentored junior engineers

Migration Project

prasanna Kumar — Fri, 10 Apr 2026 01:09:32 +0000

Project: Fault management (#Cox Communications)

Over the past several months, I’ve been part of a three‑person team executing a critical migration of multiple microservices from a traditional, self‑managed Kubernetes environment to Google Kubernetes Engine (GKE). The project involved several parallel modernization efforts:

Java upgrade – moving to the latest version and resolving all compatibility issues across the services.

UI overhaul – rewriting the user interface from scratch and integrating it with the backend services.

Secrets management – transitioning from legacy secret handling to HashiCorp Vault, with secure access from the new GKE cluster.

Infrastructure migration – re‑architecting the existing Kubernetes setup into a fully compatible, production‑ready GKE cluster.

Environment‑specific configurations – setting up SSL certificates, host mappings, UI routing, and URL configurations across development, QA, and production environments to ensure secure, consistent, and isolated deployments.

I took complete ownership of the infrastructure migration track. This included designing and provisioning the GKE cluster, ensuring full compatibility with our existing workloads, and orchestrating the smooth transition of all microservices. I also led the configuration of environment‑specific settings: managing SSL termination and certificate lifecycle, defining host and URL mappings per environment, and aligning UI integration points with backend services for dev, QA, and prod. I handled the entire lifecycle – from writing and building the cluster configuration to deploying services and validating the environment – all while maintaining zero‑downtime operations.

Beyond the technical execution, I found deep satisfaction in the end‑to‑end process: writing infrastructure as code, automating builds, managing deployments, and tailoring configurations to each environment’s needs. It has been an intense but incredibly rewarding learning experience, strengthening my expertise in cloud‑native migrations, GKE, multi‑environment management, and production Kubernetes operations.

Decorators

prasanna Kumar — Sun, 05 Apr 2026 12:39:45 +0000

A decorator is a function that modifies the behavior of another function.

Syntax:

def decorator_function(original_function):
    def wrapper_function():
        # Code to execute before the original function
        original_function()
        # Code to execute after the original function
    return wrapper_function

@decorator_function
def display():
    print("Display function executed.")
display()

Polymorphism

prasanna Kumar — Sun, 05 Apr 2026 12:20:50 +0000

Polymorphism is one of the core pillars of Object-Oriented Programming (OOP). The word itself comes from Greek: Poly (many) and Morph (forms). In programming, it means the ability of a single interface (a function, an operator, or a method) to adapt its behavior based on the type of data it is processing.

1. Duck Typing (Dynamic Polymorphism)

In languages like Python, we follow the principle: "If it walks like a duck and quacks like a duck, it’s a duck." This means we don't care about the object's class; we only care if it has the methods we need.

2. Method Overriding (Inheritance-based)

This occurs when a Child Class provides a specific implementation of a method that is already defined in its Parent Class. This allows you to treat a group of different objects as if they were the same parent type while still getting specific behavior.

3. Operator Polymorphism

This is the simplest form. A single symbol (operator) performs different actions depending on the operands.

4. Method Overloading

This allows a class to have multiple methods with the same name but different arguments (either in number or type).

Note: Python does not support traditional method overloading (like Java or C++) directly. If you define two functions with the same name, the second one replaces the first. However, we achieve this using Default Arguments or *args.

class Logger:
    def log(self, message, level="INFO"):
        print(f"[{level}]: {message}")

l = Logger()
l.log("System started")             # One argument
l.log("Connection failed", "ERROR")  # Two arguments

Since we have worked with FastAPI, we have noticed polymorphism in action with Dependency Injection. When you define a dependency, FastAPI doesn't care exactly how the class is structured inside, as long as it returns the expected type or object for your route.

Mastering FastAPI: A Complete Learning Roadmap

prasanna Kumar — Wed, 01 Apr 2026 14:22:36 +0000

FastAPI is a powerful, modern Python web framework that leverages Python type hints and ASGI to build high-performance APIs. To truly master it, you need to understand not only the framework itself but also the ecosystem of tools, protocols, and deployment practices that surround it. Below is a comprehensive guide covering all the layers, concepts, and tools you’ll need to become proficient.

1. Core FastAPI & Python Fundamentals

Python (3.8+)

Type hints – essential for FastAPI’s data validation and editor support.
Async/await – understand how async def works and when to use it (I/O-bound operations).
Generators & context managers – used for dependencies and middleware.
Packaging – pip, venv, poetry, uv for dependency management.
FastAPI Core Concepts
Routing – @app.get(), @app.post(), etc.
Path & Query Parameters – validation, default values.
Request Body – Pydantic models, Form, File, UploadFile.
Dependency Injection – functions with Depends(), reusability, sub‑dependencies.
Response Models – response_model, status codes, custom responses.
Exception Handling – HTTPException, custom exception handlers.
Middleware – built-in (CORS, GZip) and custom ASGI middleware.
OpenAPI / Swagger – automatic docs at /docs and /redoc.

2. The ASGI Stack: Starlette & Uvicorn

FastAPI is built on top of Starlette (ASGI toolkit) and uses Pydantic for data.
Starlette
Low-level ASGI handling, routing, WebSocket support, background tasks, middleware.
Learn how Starlette’s Request and Response objects work; FastAPI extends them.
Uvicorn (or Hypercorn)
ASGI server that runs your FastAPI app.
Understand multi‑worker setups (--workers), reload for development, and how to run behind a reverse proxy.
ASGI Lifecycle
How HTTP requests, WebSocket connections, and lifespan events (startup, shutdown) work.

3. Data Validation & Serialization with Pydantic

Pydantic v2 – create models with BaseModel.
Validation – Field(), custom validators, model validators.
Settings management – BaseSettings (Pydantic‑settings) for environment variables.
Nested models, Union, Optional, List, Dict.
Performance – Pydantic v2 is written in Rust (pydantic‑core) – understand how to use it efficiently.

4. Databases & ORMs

SQL Databases
SQLAlchemy – the most common ORM.
Core: connections, sessions, models.
ORM: relationships, queries, migrations (Alembic).
Async SQLAlchemy (since 1.4) – use async_sessionmaker, select with await.
SQLModel – a library by the FastAPI creator that combines SQLAlchemy and Pydantic for a unified experience.
Alembic – database migrations.
Async drivers – asyncpg (PostgreSQL), aiosqlite, aiomysql.
NoSQL Databases
MongoDB – motor (async driver) for asynchronous operations.
Redis – redis-py with async support (aioredis integrated in redis 4.0+).
Elasticsearch, Cassandra, etc.
Best Practices
Dependency injection for database sessions (e.g., get_db).
Repository pattern to abstract database logic.

5. Authentication & Security

OAuth2 with Password (and JWT) – built‑in OAuth2PasswordBearer.
JWT – python-jose for encoding/decoding.
API Keys – custom header dependencies.
HTTP Basic – HTTPBasic from FastAPI’s security utilities.
Middlewares – CORS, trusted hosts, rate limiting (slowapi).
Hashing passwords – passlib[bcrypt].

6. Background Tasks & Job Scheduling

FastAPI’s BackgroundTasks – simple tasks that run after returning a response (e.g., send email).
Celery – distributed task queue for long‑running jobs (e.g., video processing).
Use celery with Redis/RabbitMQ, integrate with FastAPI.
APScheduler – lightweight in‑process scheduling (cron‑like jobs).
Sending emails – fastapi-mail, aiosmtplib, or integration with services like SendGrid.
Example: Schedule a daily report email via APScheduler or Celery beat.

7. Real‑Time & Streaming

WebSockets
FastAPI/Starlette’s native WebSocket support.
Manage connections, broadcast messages, rooms.
Server‑Sent Events (SSE)
Use sse-starlette or implement custom streaming responses.
Streaming Responses
StreamingResponse – for large files, video, or live data (e.g., from a database cursor).
gRPC
Run a gRPC server alongside FastAPI (separate process) or use grpc-gateway to expose gRPC via HTTP.
GraphQL
Strawberry – integrate GraphQL with FastAPI via GraphQLRouter.
Alternatives: Ariadne, Graphene.
Model Context Protocol (MCP)
Emerging standard for AI tool integration – can be exposed via FastAPI endpoints.
Webhooks
Implement webhook receivers (POST endpoints) and optionally verify signatures.

8. Middleware & Advanced HTTP Features

CORS – CORSMiddleware.
GZip – GZipMiddleware.
Custom ASGI middleware – e.g., request logging, timing.
TrustedHostMiddleware – security.
Session – SessionMiddleware (Starlette’s).

9. Testing

TestClient from fastapi.testclient (based on requests).
pytest – fixtures, async tests (use pytest-asyncio).
Database testing – rollback after tests, use separate test database.
Mock external services – httpx for mocking HTTP calls.

10. Deployment & Infrastructure

Docker
Write a Dockerfile with multi‑stage builds.
Use uvicorn with workers, or gunicorn + uvicorn.workers.UvicornWorker.
Container Orchestration
Kubernetes – understand pods, services, deployments, ConfigMaps, secrets.
Helm charts for templating.
CI/CD
Git – version control, branching strategies.
Jenkins – pipelines, building, testing, pushing Docker images.
GitHub Actions / GitLab CI – modern alternatives.
Cloud Platforms
AWS (ECS, Lambda with mangum), Google Cloud Run, Azure Functions, Heroku, Fly.io.
Reverse Proxies
Nginx, Traefik, Caddy – SSL termination, load balancing.

11. Additional Protocols & Integrations

REST – the native protocol of FastAPI.
GraphQL – add a GraphQL endpoint with Strawberry.
WebSockets – for real‑time bidirectional communication.
gRPC – high‑performance RPC.
MCP – Model Context Protocol (for AI agents).
Webhooks – handle incoming events from third‑party services.

12. Chatbots & Real‑Time Messaging

Telegram Bot – use python-telegram-bot (async) with webhooks or polling, integrate into FastAPI.
Slack Bot – Slack Events API with FastAPI webhooks.
Custom chat – build with WebSockets + FastAPI.

13. Advanced Topics

Dependency Injection deep dive – Depends() with callables, classes, yield for resource cleanup.
Middleware vs. dependency – when to use each.
Performance tuning – profiling, connection pooling, async vs. sync endpoints.
OpenAPI customization – openapi_extra, response_model_exclude_unset, etc.
Pagination – implement with limit/offset or cursor‑based.
Recommended Learning Path
Python basics – focus on type hints, async/await, context managers.
FastAPI official tutorial – build a simple CRUD API, understand core concepts.
Pydantic – work through validation and settings.
SQL databases – SQLAlchemy (async) and Alembic.
Authentication – implement JWT + OAuth2.
Background tasks – start with BackgroundTasks, then Celery.
WebSockets – build a simple chat.
Testing – write tests for all endpoints.
Docker & deployment – containerize your app, deploy to a cloud platform.
Advanced protocols – GraphQL, gRPC, streaming.
CI/CD – set up GitHub Actions or Jenkins pipelines.
Kubernetes – orchestrate your app for scaling.

Essential Tools & Libraries (Summary)

Category : Tools / Libraries
Core :FastAPI, Starlette, Pydantic, Uvicorn (or Hypercorn)
Database: SQLAlchemy, asyncpg, Alembic, SQLModel, Motor, Redis
Auth :python-jose, passlib, PyJWT
Tasks: Celery, Redis/RabbitMQ, APScheduler, fastapi-mail
Testing: pytest, httpx, pytest-asyncio, factory-boy
Deployment: Docker, Gunicorn, Kubernetes, Helm, Nginx, AWS, GCP, Azure
CI/CD: GitHub Actions, GitLab CI, Jenkins
Protocols: Strawberry (GraphQL), websockets (built-in), grpcio, sse-starlette
Monitoring: Prometheus (starlette-prometheus), OpenTelemetry, Sentry
Chatbots python-telegram-bot, slack-sdk
File Handling aiofiles, python-multipart

Mastering FastAPI is not just about the framework itself—it’s about becoming proficient in the entire stack that supports modern web applications.

Mastering Database Migrations in FastAPI with Alembic

prasanna Kumar — Mon, 30 Mar 2026 16:01:07 +0000

If you're coming from Django, you might miss the built-in makemigrations. In the FastAPI world, Alembic is the industry standard. It’s powerful, but the initial setup can feel like a "configuration maze."

Here is the simplified 3-step workflow to get you up and running without the headache.

1. The "Big Three" Setup Steps

To get Alembic talking to your FastAPI models, you need to configure these three areas:

A. The Initialization

Run this in your terminal to create your migration environment:

alembic init migrations

This creates a migrations/ folder and an alembic.ini file.

B. The alembic.ini (The Address Book)

This file tells Alembic where your database lives. Find the line sqlalchemy.url and update it.

Pro-Tip: If you use a .env file, leave this blank and load it dynamically in env.py to keep your credentials secure!

C. The env.py (The Brain)

This is the most critical file. Inside migrations/env.py, you must link your models:

# migrations/env.py
from my_app.db.base import Base  # Import your SQLAlchemy Base/SQLModel
target_metadata = Base.metadata    # Link it here so Alembic "sees" your tables

2. The Development Loop

Once setup is done, you only need to remember this 3-step loop whenever you change your database schema:

1. Change: Edit your Python models (e.g., add a bio column to your User class).

2. Revision: Generate the migration script:

alembic revision --autogenerate -m "add user bio"

3. Upgrade: Apply the changes to the live database:

alembic upgrade head

3. Important "Gotchas" to Remember

The Autogenerate Trap: Alembic isn't psychic. It can miss renamed columns or specific Enum changes. Always check the generated file in migrations/versions/ before running the upgrade.

Async Support: Using AsyncSession? You must initialize with the async template:

alembic init -t async migrations

The alembic_version Table: Alembic creates a table in your DB to track the current migration ID. If your DB and code get out of sync, this is the first place to look.

inspired by: Cheat sheet of 'Alembic' commands