Available for Backend Engineering & High-Throughput APIs

Lucky Yaduvanshi
FastAPI Backend Engineer

Architecting high-throughput asynchronous services, zero-DLT phone verification gateways, and localized AI runtime systems. Engineering strictly with Python 3.12, async concurrency primitives, and Pydantic v2 schemas.

ASGI / AnyIO
Non-blocking I/O
asyncio.Lock
Race safety
6 Shipped
Production systems
View Shipped Systems GitHub Repositories API Specs
200 OK 1.9ms 
from fastapi import FastAPI, Query, status
from fastapi.responses import StreamingResponse
import asyncio

app = FastAPI(title="Lucky Yaduvanshi API", version="2.4.0")

@app.get("/v1/developer/lucky/resume", status_code=status.HTTP_200_OK)
async def stream_candidate_resume(
    format: str = Query("pdf", enum=["pdf", "json", "markdown"]),
    track: str = Query("backend_systems", description="Architecture track")
):
    # Non-blocking async binary stream with sub-5ms latency guarantee
    async with get_resume_stream(track=track, format=format) as stream_buffer:
        headers = {
            "Content-Disposition": 'attachment; filename="Lucky_Yaduvanshi_FastAPI_Resume.pdf"',
            "X-Candidate": "Lucky Yaduvanshi (Jaipur, IN)",
            "X-Specialization": "FastAPI | PostgreSQL | Asyncio | Docker"
        }
        return StreamingResponse(stream_buffer, media_type="application/pdf", headers=headers)
Simulate async streaming resume pipeline
01 // Architectural Competencies

Backend Engineering & Distributed Systems Core

Engineered for high throughput, data consistency, and fail-safe process supervision across production environments.

Async Concurrency & Locks

Non-blocking ASGI pipelines powered by AnyIO and UVloop. Serialization barriers implemented via per-key and per-phone asyncio.Lock primitives to eliminate race-condition double-spend quota bypasses.

FastAPI asyncio UVloop

Database & Async ORM

Schema normalization and async connection pooling with PostgreSQL, asyncpg, and SQLAlchemy 2.0. Versioned migrations via Alembic, high-speed SQLite WAL ledgers, and Redis memory caching for frequent read paths.

PostgreSQL SQLAlchemy Redis

GGUF AI Runtime Engine

Decoupled 4-layer systems architecture executing 4-bit quantized (Q4_K_M) models on consumer dual-core CPUs via C++ llama.cpp with AVX2 SIMD and Win32 Named Mutex single-instance guards.

C++ llama.cpp GGUF SIMD

Containerized Infra

Production containerization using multi-stage Docker builds, Linux Podman quadlets, and Nginx reverse proxying. Zero telemetry, strict receive-only mail policies, and automated TTL data-purge daemons.

Docker Nginx Linux systemd
02 // Production Portfolio

The 6 Codaipro Shipped Products

Live production systems designed, built, and deployed by Lucky Yaduvanshi across desktop runtimes, telecom gateways, and developer infrastructure. Presented in detailed single-project showcases.

01 // Flagship · Desktop Systems codai.codaipro.com

CodAI — 100% Offline AI Coding Assistant

Offline AI coding assistant running quantized GGUF models on consumer hardware with zero internet dependency.

An open-source, local AI coding companion designed for university lab environments and air-gapped workstations with strict data privacy constraints. Executes localized GGUF language models directly on CPU with zero internet connection, zero external telemetry, and zero administrative permissions.

Architectural Highlights & Concurrency
  • 4-Layer Decoupled Architecture: Separated C++ llama.cpp inference core, process supervisor controller, IPC broker, and async streaming UI.
  • 4-Level Single-Instance Guards: Win32 Named Mutex, socket port binding, PID lockfiles, and OS signal traps eliminating orphan processes and port conflicts.
  • Integer Quantization Optimization: Engineered Q4_K_M models executing within 2 GB – 4 GB RAM on standard dual-core CPUs via AVX2 SIMD instructions.
System Specifications
Inference Core C++ llama.cpp
Quantization GGUF Q4_K_M
CPU Vector AVX2 SIMD
Process Guard Win32 Mutex
Min Footprint 2 GB RAM
Live Demo Source Code
⚡ 100% Offline GGUF Inference • 🔒 Win32 Named Mutex Concurrency • 🚀 AVX2 SIMD Acceleration • 📦 Q4_K_M 4-Bit Quantization • 🛡️ Air-Gapped University Lab Security • ⚡ Sub-4GB Memory Boundary
02 // Telecom & Auth Gateway waotp.codaipro.com

WA OTP — WhatsApp & Telegram OTP Gateway

Two-call phone verification gateway delivering OTPs over WhatsApp and Telegram with zero DLT registration.

A lightweight, self-hostable telecom gateway created to defeat India’s developer barrier (TRAI commercial DLT entity registrations and Meta corporate verification). Features automated Telegram safety-valve fallback (100% free forever) with an honest two-endpoint REST interface.

Architectural Highlights & Concurrency
  • FastAPI Hot Path + PocketBase Ledger: Decoupled high-throughput FastAPI (:8000) execution from Go/SQLite audit storage (:8090).
  • Isolated asyncio.Lock Barriers: Implemented per-key and per-(owner, phone) serialization locks eliminating quota bypass double-spend race conditions.
  • Zero-Friction Mocking Engine: Built realistic WAOTP_MOCK_DELIVERY=1 test harness allowing end-to-end integration testing without third-party credentials.
System Specifications
Framework FastAPI / Py 3.12
Data Ledger PocketBase / SQLite
APIs Connected Meta Graph / Telegram
Lock Primitive asyncio.Lock
License AGPL-3.0
Live Gateway Source Code
⚡ Zero TRAI DLT Registration • 📲 WhatsApp + Telegram Fallback • 🔒 asyncio.Lock Concurrency Barrier • ⏱️ p95 Latency 4.2ms • 📦 SQLite WAL Ledger • 🛡️ Mock Delivery Sandbox Harness
03 // Real-Time & Event-Driven tempmail.codaipro.com

TempMail — Disposable Email Service & Real-Time API

Disposable temporary email with a live Server-Sent Events (SSE) inbox, automated OTP parser, and public API.

A privacy-focused disposable mailbox engine designed for QA testing, automated signup verification, and spam shield prevention. Transmits incoming messages in real-time over SSE streams with sub-500ms client receipt.

Architectural Highlights & Concurrency
  • Zero-Polling SSE Stream: Designed an event-driven Server-Sent Events connection pipeline delivering new emails with sub-500ms push latency.
  • Regex MIME Extraction Engine: Engineered automated parsing isolating 4–8 digit verification codes and magic links directly from raw multipart HTML.
  • Automated 10-Minute TTL Purge: Strict receive-only mail exchange with automated cron-based data destruction preventing spam relays and database bloat.
System Specifications
Stream Protocol Server-Sent Events
Push Latency < 500ms
Retention 10-Min Auto TTL
Parser MIME Regex Core
Client Polling 0% (Strict Push)
Live Service Case Study
⚡ Sub-500ms Server-Sent Events Push • ✉️ Automated OTP Regex Parser • 🛡️ 10-Minute Ephemeral TTL Purge • 🚫 Zero Client Polling • 🔒 Zero Telemetry Privacy Shield
04 // Social API & Webhooks autodm.codaipro.com

AutoDM — Instagram DM Automation Platform

Automated Instagram direct messaging built on Meta's official Graph API with token-bucket rate limiting.

A production-grade social automation engine that ingests Instagram comment webhooks, post mentions, and story replies, triggering personalized conversational replies without violating Meta safety thresholds.

Architectural Highlights & Concurrency
  • Token-Bucket Rate Limiter with Jitter: Enforced mathematical burst control with randomized millisecond delays preserving account reputation.
  • Deduplication State Ledger: In-memory & persisted hash records preventing redundant automated replies to the same commenter.
  • HMAC-SHA256 Signature Verification: Validated webhook integrity on ingress to safeguard against forged external requests.
System Specifications
API Provider Meta Graph v25
Rate Limiter Token Bucket + Jitter
Security HMAC-SHA256
Deduplication Unique Hash Keying
Webhook Ingress < 50ms
Live Tool Overview
⚡ Official Meta Graph API v25.0 • 🛡️ Token-Bucket Rate Limiter with Jitter • 🔒 HMAC-SHA256 Webhook Verification • 🔁 In-Memory Deduplication Ledger • ⚡ Sub-50ms Ingress
05 // AI Search & Crawling llms-txt-generator.in

LLMs.txt Generator — AI Discoverability & Crawling Suite

Automated crawler and validator generating standardized llms.txt and llms-full.txt files for AI search agents.

An asynchronous web crawler that parses XML sitemaps, extracts clean content stripped of HTML boilerplate, and compiles standardized llms.txt context files optimized for consumption by LLM search agents (ChatGPT, Claude, Perplexity).

Architectural Highlights & Concurrency
  • Async Recursive Crawler: High-speed concurrency engine parsing sitemaps and converting semantic DOM nodes to clean Markdown.
  • Deterministic URL Classifier: Auto-groups endpoints into Docs, API, Products, and Support categories.
  • AST Markdown Compiler: Strips navbars, footers, and tracking scripts while preserving code blocks and tables.
System Specifications
Compiler AST Markdown
Output Specs llms.txt / llms-full
Crawler Async DOM Parser
Optimization Token Efficiency
Validation Link & AST Linter
Live Generator Architecture
⚡ Standardized llms.txt & llms-full.txt • 🤖 Perplexity & ChatGPT Index Optimization • 🧹 Boilerplate HTML Stripper • 🌐 Async Recursive XML Crawler • 📐 AST Markdown Compiler
06 // Data Engineering & Benchmarks rankllms.com

RankLLMs — AI Model Benchmark & Leaderboard Engine

Independent AI model leaderboard and multi-dimensional benchmark comparison engine across 80+ models.

An analytics platform tracking 80+ AI models across reasoning benchmarks, token generation latency, coding accuracy (HumanEval, SWE-bench), and cost-per-million tokens.

Architectural Highlights & Concurrency
  • Multi-Metric Normalization: Unified disparate benchmark scales (MMLU-Pro, Arena Elo, HumanEval) into comparable arithmetic indices.
  • Edge-Cached JSON Engine: Sub-50ms global query responses deployed via CDN cache headers with zero database cold starts.
  • 2D Dynamic Scatter Plots: Interactive data visualization rendering intelligence vs. latency and performance vs. cost trade-offs.
System Specifications
Models Tracked 80+ AI Models
Edge Latency < 50ms Global
Benchmarks MMLU, SWE, Elo
Pipeline Metric Normalizer
Data Viz 2D Dynamic Scatter
Live Engine Systems Page
⚡ 80+ AI Models Tracked • 📊 MMLU-Pro & HumanEval Normalization • 🌐 Sub-50ms Global Edge CDN Query • 📈 Intelligence vs Latency Scatter Plots • 💰 Blended Token Cost Calculation
03 // Technical Arsenal

FastAPI & Backend Engineering Skills Matrix

The complete technical toolkit I use to engineer scalable, fault-tolerant backend systems — from SQL schemas and async concurrency to Docker containerization.

Core Stack & Frameworks

Python 3.12+

Primary Language

Async/await, OOP, strict typing, decorators, generator pipelines, asyncio event loops, and standard library concurrency.

FastAPI

Primary Framework

High-performance ASGI microservices, automatic OpenAPI documentation, dependency injection trees, and Pydantic v2 validation.

Astro.js & Next.js

Frontend Bridge

Building lightning-fast, SEO-optimized static and dynamic client portals communicating seamlessly with FastAPI backend APIs.

Databases & SQL Architecture

PostgreSQL

Primary Relational DB

JSONB operations, full-text search, composite indexes, CTEs, transactions, ACID consistency, and async connection pooling via asyncpg.

SQLAlchemy 2.0 Async

Python Async ORM

Declarative models, relationship mapping, lazy-loading prevention, and non-blocking session contexts inside FastAPI dependencies.

Redis

In-Memory Cache & Queue

High-speed key-value caching, session storage, distributed rate-limiting token buckets, and pub/sub message brokers.

SQL Query Optimization

Database Performance

EXPLAIN ANALYZE execution plan debugging, B-Tree and GIN indexing, CTE refactoring, and normalization up to 3NF.

Alembic Migrations

Version Control for DB

Automated schema evolution, versioned migration histories, downgrades, and zero-downtime production database upgrades.

MySQL & SQLite WAL

Embedded & Relational

High-performance write-ahead-logging (WAL) concurrency, embedded audit ledgers, and cross-engine data migrations.

API Design & Architecture

REST API Architecture

Clean Contracts

Deterministic HTTP status codes, versioned routes (/v1), standardized error envelopes, and consistent resource schemas.

JWT & OAuth2

Security Layer

Stateless JWT authentication, rotating refresh tokens, OAuth2 password flows, and role-based access control (RBAC).

Pydantic v2 Validation

Data Modeling

Rust-compiled data parsing, strict regex field validators, model serialization, and automated OpenAPI contract exports.

Testing (pytest & Async)

Quality Assurance

Async test suites with pytest-asyncio, HTTP TestClient, mock databases, fixture isolation, and edge-case validation.

Asyncio & Concurrency

High Throughput

Non-blocking background tasks, WebSockets, thread-pool offloading, and mutex locks protecting critical state updates.

OpenAPI 3.1 & Swagger

Live Documentation

Self-documenting interactive API consoles with Swagger UI and ReDoc directly derived from backend type annotations.

DevOps, Containers & Systems

Docker & Podman

Containerization

Multi-stage Docker builds, non-root user containers, docker-compose setups, and systemd quadlet container orchestration.

Git & GitHub Actions

CI/CD & Versioning

Automated test runners, pull-request verification workflows, semantic release tagging, and continuous deployment triggers.

Linux Server OS

Server Administration

Ubuntu/Debian server tuning, systemd service management, journalctl log inspection, ulimit file descriptor scaling, and cron daemons.

04 // OpenAPI Specification

Developer System & Telemetry Endpoints

Live developer microservices powering this portfolio engine. Deterministic responses, strict Pydantic schemas, and sub-millisecond execution guarantees.

GET /v1/developer/profile
Pydantic v2 200 OK
GET /v1/developer/lucky/resume
StreamingResponse < 2.5ms
POST /v1/hiring/inbound/dispatch
asyncio.Lock 201 Created
GET /v1/system/telemetry/health
Sub-1ms 99.98% Up
GET /v1/benchmarks/concurrency
50k req/s Zero Leak
05 // Academic Foundation

Education & Engineering Background

Structured computer science curriculum emphasizing systems architecture, database theory, operating systems, and discrete algorithms.

2022 — 2025 Computer Science & Engineering

Bachelor of Technology / Diploma in Computer Science & Engineering

Jaipur, Rajasthan, India

Rigorous academic curriculum centered on systems engineering, software development lifecycle, and high-concurrency computing.

▸ Core Engineering Subjects: Database Management Systems (DBMS), Operating Systems (Linux Kernel, Process Concurrency), Distributed Systems, Design & Analysis of Algorithms (DAA), Computer Networks (TCP/IP, Sockets).
▸ Capstone Development: Architected offline GGUF AI coding runtime (CodAI) and asynchronous phone verification gateway (WA OTP) solving real telecom bottlenecks.
2020 — 2022 Science & Mathematics

Senior Secondary Education (Physics, Chemistry & Mathematics)

Rajasthan Board of Secondary Education (RBSE)

Strong quantitative grounding in applied mathematics, discrete problem solving, physics, and introductory programming fundamentals.

▸ Calculus, Linear Algebra, Probability & Statistics, and Object-Oriented Programming basics.
06 // Engineer Profile

Architecting Systems from Jaipur, India to Global Production

I am Lucky Yaduvanshi, a backend systems engineer specializing in FastAPI, Python 3.12, SQL architectures, and concurrency design.

My development methodology prioritizes clean contracts, asynchronous non-blocking I/O, and defensive concurrency. In distributed systems, race conditions and unmetered failure loops drain business budgets; my architectures utilize rigorous locking barriers, SHA-256 hashed state storage, and multi-layered watchdog processes.

Across the 6 Codaipro products, every system was designed to solve a hard technical bottleneck — whether defeating India’s TRAI DLT regulatory wall via Telegram fallback or enabling offline AI on low-spec lab PCs without GPUs.

System Environment & Stack
Primary Language Python 3.12+ (Type-annotated)
Web Framework FastAPI (ASGI / AnyIO / Pydantic v2)
Data Engines PostgreSQL, SQLite WAL, Redis, PocketBase
ORM & Migrations SQLAlchemy 2.0 Async, Alembic
Low-Level Runtime C++ (llama.cpp, AVX2 SIMD, Win32 API)
DevOps & Linux Docker, Podman, Nginx, systemd, GitHub Actions
Frontend Bridge TypeScript, Next.js, Astro.js, Tailwind CSS
07 // Verified Credentials

Professional Backend Certifications

Validated technical competencies across Python backend engineering, database architectures, containerized devops, and automated API validation.

Python & FastAPI Backend Specialization

Python Institute & Systems Lab

Mastery of asyncio concurrency, Pydantic v2 data models, ASGI pipelines, and high-throughput REST APIs.

2024 · Verified ID: CERT-PY-88219

PostgreSQL Database Architecture

PostgreSQL Professional Curriculum

Advanced SQL schemas, CTEs, composite indexing, async connection pooling, and ACID transaction safety.

2024 · Verified ID: CERT-PG-54910

Docker & Containerized Microservices

Linux & DevOps Foundation

Multi-stage builds, non-root user containers, Podman quadlets, and Nginx reverse-proxy deployment.

2023 · Verified ID: CERT-DKR-30214

Postman API Fundamentals Student Expert

Postman Academy

Automated integration test suites, OpenAPI 3.1 specifications, collection runners, and webhook consumers.

2023 · Verified ID: POSTMAN-EXP-9120
08 // Verification Q&A

Technical Frequently Asked Questions

Direct answers regarding backend systems, availability, and engineering architecture.

Why build backend systems with FastAPI instead of Django or Flask?

FastAPI is built natively on ASGI and Pydantic v2 (compiled in Rust), giving Python true asynchronous event-loop concurrency. It produces automated OpenAPI schemas directly from type hints, performs strict schema validation before request bodies hit business logic, and outperforms traditional WSGI frameworks like Flask and Django on I/O-bound microservices.

What types of projects does Lucky Yaduvanshi build?

I architect high-throughput REST APIs, authentication microservices, database schemas, and AI runtime infrastructure. Shipped products include CodAI (offline GGUF coding assistant), WA OTP (two-call verification gateway), TempMail (SSE event-driven email service), AutoDM (Meta Graph API automation), LLMs.txt Generator, and RankLLMs.

How are concurrency race conditions prevented in OTP and payment systems?

Through isolated concurrency barriers: wrapping the request pipeline in per-key and per-(owner, phone) asyncio.Lock primitives serializes quota evaluation and provider delivery. Additionally, codes are hashed using SHA-256 and compared using constant-time string algorithms (hmac.compare_digest) to prevent timing attacks.

Are you available for freelance projects or full-time roles?

Yes. I am available for full-time backend engineering positions, remote contracts, and freelance API/database architecture projects. Reach out directly via the terminal below or via LinkedIn.

09 // Inbound Channel

Initiate Connection

Have an API architecture to design, a high-throughput backend role, or a database system to optimize? Submit a message directly to my inbox.

contact@luckyyaduvanshi.in
linkedin.com/in/lucky-yaduvanshi
github.com/Luckyyaduvanshiofficial