Varun
Kumar
Andigari

Multi-tenant backend transformation for an enterprise client: an API gateway and microservices aggregation layer processing high-volume customer orders, product-catalog requests and account data across legacy and cloud systems.

• Designed microservices using Python, FastAPI, Flask and Pydantic, reducing API response times by 30%; implemented circuit-breaker patterns for downstream calls to improve resilience and prevent cascading failures.How it worked

  Downstream legacy services (billing and inventory databases) were slow and occasionally timed out at peak load. I built FastAPI microservices for the high-frequency paths and added circuit breakers (Tenacity-style) so a failing vendor or inventory API couldn't take the whole customer portal down.

  • Async handlers: endpoints are async def on Uvicorn/uvloop, so the event loop yields during DB reads and external HTTP calls instead of blocking a worker.
  • Process model: Gunicorn managing Uvicorn workers, one per CPU core, to use the full machine.
  • Validation: Pydantic for fast request parsing and serialization, keeping CPU overhead per request low.
  • Connection pooling: persistent pools for PostgreSQL (SQLAlchemy async sessions) and Redis, removing per-request TCP handshake latency.

  Caching + async pipeline: avg API latency down 30%
• Implemented RESTful APIs and gRPC services in Python, optimizing communication between distributed systems with FastAPI and asyncio to improve latency, throughput and overall performance.How it worked

  Internal service-to-service traffic over REST/JSON carried too much serialization and network overhead, so I moved the critical internal paths to gRPC with asyncio.

  • Protobuf: compact binary serialization instead of text JSON, cutting payloads by roughly 60 to 70% on the wire.
  • HTTP/2 multiplexing: many concurrent requests over one long-lived connection, with no head-of-line blocking, no repeated connection setup.
  • asyncio fan-out: with gRPC's async stubs, a service fires dozens of inter-service calls at once via asyncio.gather() without blocking the main thread.
• Optimized database performance using PostgreSQL, SQLAlchemy and Redis, implementing caching strategies and CQRS to scale data access patterns and support high-volume workloads.How it worked

  The database was getting hammered by read-heavy traffic: thousands of users searching catalogs and viewing order history at once. I split the read and write paths with CQRS: writes go straight to PostgreSQL, heavy reads are served from Redis.

  • Command path (writes): SQLAlchemy AsyncSession over asyncpg with explicit pool bounds (pool_size=20, max_overflow=10) and pool recycling, inside explicit transactions for ACID guarantees, which is what prevented connection-pool exhaustion.
  • Query path (reads): cache-aside on Redis with structured keys like catalog:item:{id}. Hit → deserialized and returned in milliseconds, PostgreSQL skipped. Miss → optimized read query, then written back with a TTL.
  • Consistency: every write invalidates or updates the affected Redis key, with a 5 to 15 minute TTL as a safety net against stale data.
• Integrated Generative AI and LLM APIs into Python applications using LangChain, RAG and prompt engineering to build a context-aware document Q&A system that retrieved indexed content and produced grounded responses.How it worked

  Support reps and sales-ops needed to query technical product docs and customer-policy files without digging through static PDFs. I built an internal RAG pipeline on LangChain where they ask in plain language and get grounded answers.

  • Ingestion: PDFs, policy files and manuals parsed and split with a recursive character splitter (chunk_size=1000, overlap=200) to keep meaning across sentence boundaries.
  • Vector store: chunks embedded and stored in a vector database (PostgreSQL/pgvector or Redis vector search).
  • Retrieval: embed the question, run cosine similarity, take the top 3 to 5 chunks and inject them into the prompt as context.
  • Hallucination control: the system prompt says to answer only from the provided context, and to say "I don't know" when it isn't there.
• Developed an MCP (Model Context Protocol) server in Node.js to expose internal APIs and business data as reusable tools for LLM-powered applications, with tool schemas, request validation and secure service integration.How it worked

  To connect the AI system to live backend data, I built an MCP server in Node.js that acts as a secure bridge: the LLM agent can call internal REST APIs (live order status, customer account tier) without any of that being hardcoded into prompts.

  • Tool schemas: each tool (e.g. get_order_status(order_id), get_customer_tier(account_id)) has a strict JSON schema; arguments are validated before any request runs, so malformed calls never reach the backend.
  • Auth: every request carries a scoped OAuth 2.0 JWT for the agent's session; the server verifies the signature and enforces RBAC so a user can't read data above their permission level.
• Automated CI/CD pipelines (Jenkins, ArgoCD) and Kubernetes deployments for Python/AI workloads, cutting deployment cycles by 60% with zero downtime while securing APIs via OAuth 2.0 and RBAC.How it worked

  Every service and AI workload ships through automated pipelines onto Kubernetes, with rolling updates so a release never interrupts live users.

  • CI (Jenkins): on push, runs lint, static analysis and unit/integration tests (PyTest/Jest); if gates pass, builds a multi-stage Docker image tagged with the Git commit SHA and pushes it to the registry.
  • CD (ArgoCD, GitOps): Jenkins updates the image tag in a manifest repo; ArgoCD detects the drift and syncs the cluster, with no imperative kubectl apply from CI.
  • Zero downtime: RollingUpdate with maxSurge: 25%, maxUnavailable: 0; readiness probes on /healthz so traffic only reaches warmed-up pods, liveness probes restart unresponsive ones.
  • Security: OAuth 2.0 + JWT at the gateway, signatures checked against JWKS, roles and scopes enforced (RBAC) before a request reaches any internal service.

  Deployment cycles down 60%, zero downtime

• Deployed PyTorch ML models (EKF, online LSTM) into production for real-time state estimation, forecasting and autonomous tuning, integrating GenAI/LLMs to interpret model outputs.
• Engineered a Python/Flask AI backend with Redis caching and WebSocket dashboards (Chart.js), streaming multi-API data to process 2.2M+ records and render real-time predictions, accuracy metrics and LLM insights.
• Resolved a 146 GB log-growth production outage, freeing 157 GB of disk space through root-cause analysis, while refactoring a 1,200-line monolithic codebase into a modular Python architecture for scalable AI/ML workflows.

Backend operations platform that automates network provisioning and service activation across OSS/BSS systems: the bridge between a customer placing an order and the network infrastructure actually configuring and activating that service.

• Engineered Python and Node.js microservices (FastAPI, Flask, REST APIs) to automate telecom network provisioning and activation workflows across OSS/BSS systems, boosting data-processing efficiency by 30% and reducing manual operational overhead.How it worked

  Originally, operators manually verified network capacity and pushed configurations across legacy databases for every enterprise provisioning request. I built microservices that ingest those orders, validate inventory and trigger network-activation APIs automatically.

  • Async ingestion: orders arrive via REST webhooks; the API validates the payload with Pydantic and immediately returns 202 Accepted with an order_id, handing heavy orchestration to a background queue (Celery / Redis / RabbitMQ) so HTTP calls never time out at peak.
  • Inventory validation: workers query PostgreSQL network inventory for port availability, circuit paths and bandwidth constraints.
  • No double-booking: Redis distributed locks prevent two orders from claiming the same port; each order moves through an explicit state machine: PENDING → VALIDATING → PROVISIONING → ACTIVE.
  • Legacy adapters: lightweight Node.js/Flask wrappers translate modern JSON into the legacy SOAP/XML that downstream network controllers expect.
  • Resilience: exponential backoff and retry policies with Python's tenacity absorb transient network failures without operator intervention.

  Data-processing efficiency +30%
• Integrated automated test suites for functional, non-functional and regression testing using Python, PyTest, Selenium and Maven, increasing test coverage by 50% and reducing regression test cycles by 30%.How it worked

  Activation pipelines touch critical infrastructure, so a production bug could take down live customer links. I built PyTest suites for API/unit tests and Selenium for end-to-end regression, wired into Jenkins with quality gates that block a merge or deploy if they aren't met.

  • Isolation: external OSS/BSS responses and third-party webhooks are mocked (unittest.mock / pytest-mock) so tests never touch live telecom hardware.
  • Fixtures: reusable PyTest fixtures spin up isolated PostgreSQL databases in Docker, run inside rollback-able transactions and tear down automatically, with no cross-test contamination.
  • Edge cases at scale: @pytest.mark.parametrize pushes hundreds of malformed payloads (bad VLAN IDs, missing bandwidth, expired tokens) through the same test.
  • E2E: Selenium WebDriver against the provisioning-agent portal using the Page Object Model, so UI tweaks don't break the suite; run headless in Docker (selenium/standalone-chrome) nightly and on release builds.
  • Gates: Jenkins runs pytest --cov and fails the build below 85% coverage or on any high-severity SonarQube finding, posting status checks that block pull requests.

  Coverage +50% · regression cycles down 30%
• Leveraged GenAI and LLMs to automate network incident analysis, correlate troubleshooting data and deliver actionable recommendations, streamlining operations and network service assurance.How it worked

  When provisioning failed (port timeouts, invalid VLAN tags, legacy API timeouts), support engineers spent hours hunting through raw logs scattered across systems. I helped build an internal GenAI log-analysis service that finds the root cause and writes plain-English fixes.

  • Correlation: a Python pipeline ingests failure events, strips heartbeat noise, extracts identifiers (order_id, device IP, error code, timestamp) and stitches logs from microservices and legacy devices into one incident trace via the order_id correlation ID.
  • Token control: a sliding window of about five minutes around the failure isolates stack traces, 4xx/5xx statuses and hardware-timeout signals, keeping context small and API calls fast and cheap.
  • Structured prompting: role context + incident telemetry + an enforced JSON output: root cause, confidence score, affected subsystem and recommended steps.
  • Grounding: the model may only diagnose from the supplied logs and known operational playbooks, preventing invented hardware commands.
  • Delivery: summaries land on support dashboards (or Slack/Teams webhooks) so engineers can review and act in minutes.

  Lower mean time to resolution for provisioning incidents
• Automated Python test execution and deployment via Jenkins CI/CD pipelines with automated release gates, reducing manual effort by 40% and ensuring Dev/QA environment consistency.
• Optimized PostgreSQL queries, Python services and API processing workflows supporting network inventory, service-order and provisioning data, reducing average API response time by 25% for high-volume telecom transactions.How it worked

  The database held millions of rows of inventory and order state, and at peak provisioning hours long-running queries bottlenecked the API. I traced the slow queries, fixed the SQL and indexes, and reshaped how Python handled the data.

  • Diagnosis: pg_stat_statements plus log_min_duration_statement (queries over ~200 ms) to find the offenders; EXPLAIN (ANALYZE, BUFFERS) to spot sequential scans, inefficient nested-loop joins and heavy disk I/O.
  • Indexing: composite indexes on co-queried columns (e.g. (status, location_id)) turned full scans into index scans.
  • Query refactor: unindexed subqueries and outer joins rewritten as explicit INNER JOINs so the planner can use hash and merge joins.
  • ORM fixes: eliminated N+1 queries with joinedload() / selectinload(); replaced SELECT * with explicit field selection and added cursor-based pagination to cap memory and payload size.

  Avg API response time down 25%