Hyderabad, India

Akash Akuthota — Backend Engineer & AI Systems Developer

Backend Engineer building production-oriented APIs, AI-integrated systems, Retrieval-Augmented Generation pipelines, and secure authentication architectures using Python, FastAPI, PostgreSQL, Redis, Qdrant, and OpenAI APIs.

Backend Engineering Intern @ Khwaaish
Open to Full-Time Opportunities
0+
Backend Projects
0
Live API Deployments
0
AI/RAG Systems Built
2021–2025
CS Graduate, Sathyabama

About Me

I'm a Computer Science graduate from Sathyabama Institute of Science and Technology (B.E. CSE, CGPA: 7.96/10) and a Backend Engineer focused on building reliable backend systems, AI-powered applications, and scalable APIs.

My interests include distributed systems, Retrieval-Augmented Generation (RAG), asynchronous processing, secure authentication architectures, and production-ready backend design. I enjoy designing systems that prioritize maintainability, reliability, observability, and performance while solving real-world engineering problems.

I prefer understanding the underlying architecture of systems rather than relying solely on abstractions. My focus is on building practical solutions with strong engineering fundamentals — prioritizing reliability, observability, and maintainability over surface-level complexity.

What I Work With

FastAPIPythonPostgreSQLRedisQdrantOpenAI APIRAG PipelinesJWT AuthSQLAlchemyDockerKafkaLangChainRenderVercelREST APIsRBACAsync ProcessingPydanticAPScheduler

Experience

Backend Engineering Intern

Khwaaish
Current · Ongoing
India (Remote/Hybrid)

Contributing to backend services and API development supporting AI-powered workflows and platform features.

  • Backend API development for platform features
  • Feedback systems and analytics endpoints
  • Database integration and query optimization
  • AI workflow support and feature implementation
  • Backend architecture improvements
PythonFastAPIPostgreSQLREST APIs
What I've Shipped

Engineering Highlights

Built AI-assisted debugging platform using Kafka, Qdrant, Redis, and OpenAI — combining async ingestion pipelines with RAG-based root cause analysis.

Designed secure authentication systems with JWT refresh token rotation, reuse detection, RBAC, and Redis-backed rate limiting and token blacklisting.

Developed and deployed production FastAPI applications with PostgreSQL, Redis, and cloud infrastructure on Render, Vercel, and Upstash.

Built semantic retrieval systems using OpenAI embeddings, Qdrant vector search, metadata filtering, and context-aware response generation.

Implemented Kafka-driven asynchronous event processing workflows with fault-tolerant retry mechanisms and structured observability logging.

Selected Work

Projects

Flagship ProjectActive Development

AI Debugging Copilot for Distributed Systems

PythonFastAPIKafkaDoclingQdrantRedisOpenAI APIDocker

A production-style AI backend system designed to help developers investigate incidents, failures, and debugging scenarios across distributed systems using Retrieval-Augmented Generation (RAG) and LLM-powered root cause analysis.

Key Features
  • Kafka decouples ingestion from downstream processing — handles spikes without blocking the retrieval layer
  • Docling-powered document parsing pipeline with semantic chunking for improved retrieval grounding quality
  • Qdrant vector store with metadata enrichment (user_id, chunk tracking, embedding versioning) for filtered semantic search
  • Retrieval-Augmented Generation grounds LLM responses in retrieved context — reduces hallucination risk
  • Redis caching layer reduces repeated LLM inference cost and improves response latency
  • Fault-tolerant LLM integration: exponential backoff, timeout protection, and safe fallback responses
  • API key authentication middleware + Redis per-key rate limiting prevent abuse at the gateway layer
  • Structured logging and observability-oriented workflows across all pipeline stages
Architecture Flow
1Distributed Services (log sources)
2FastAPI Ingestion API
3Kafka Producer
4Kafka Consumer
5Embedding Pipeline (OpenAI Embeddings)
6Qdrant Vector Store
7Retrieval Layer (RAG)
8OpenAI LLM (Root Cause Analysis)
9AI Debugging Response → Client
Upcoming (Phase 2)
Real-time Log IngestionHybrid Search (Vector + Keyword)Prometheus / GrafanaMulti-user API KeysAWS DeploymentCI/CD Pipeline
Live ✓

Secure Product Inventory Backend

PythonFastAPIPostgreSQLRedisSQLAlchemyReactRenderVercel

A production-oriented full-stack backend system demonstrating secure authentication, Redis-based security controls, inventory management, cart workflows, and scalable API architecture. Backend is the primary focus; React frontend serves as a client interface.

Key Features
  • JWT access/refresh token rotation with reuse detection and HTTPOnly cookies
  • Redis-based rate limiting (per-IP and per-email), token blacklisting, TTL expiration
  • Role-Based Access Control (Admin: full CRUD · User: browse + cart)
  • Bcrypt password hashing, structured security event logging
  • APScheduler background tasks for token cleanup and maintenance
  • Modular architecture: routing → services → database → auth → security layers
  • Full product inventory CRUD + cart management with user isolation
  • Deployed on Render, Neon PostgreSQL, Upstash Redis, Vercel
Live ✓

Finance Data Processing & Access Control Backend

PythonFastAPIPostgreSQLRedisSQLAlchemyPydantic

A production-ready FastAPI backend for financial data processing with role-based access control and real-time dashboard analytics. Demonstrates clean modular architecture, secure authentication, and scalable data handling.

Key Features
  • JWT authentication with refresh token rotation, reuse detection, Redis blacklisting
  • 3-tier RBAC: Viewer (dashboard) · Analyst (read + analytics) · Admin (full access)
  • Financial records CRUD with soft delete, filtering, and pagination
  • Dashboard analytics: income/expense/net balance, category breakdown, monthly trends
  • Redis rate limiting and structured logging for monitoring
  • HTTPOnly cookie-based refresh token storage
  • Clean layered architecture: Routes → Services → Models → Schemas
Research ProjectIEEE Published

Cardiac Risk Prediction System

PythonScikit-LearnFastAPIPandasNumPySMOTE

An end-to-end machine learning system for predicting cardiac risk using ensemble learning techniques, built on an IEEE research implementation with ~3,200+ clinical records. Implementation aligned with IEEE-published research on hybrid ML models for cardiac risk prediction.

~88% Accuracy~94% ROC-AUC
Key Features
  • Voting Classifier ensemble: Logistic Regression, Random Forest, Decision Tree, KNN
  • SMOTE for class imbalance handling on clinical dataset
  • Comprehensive EDA (Exploratory Data Analysis) pipeline
  • FastAPI-based real-time prediction API
  • Clinical prediction workflow from raw input to risk score
  • Dietary recommendation integration for high-risk predictions
What I Build With

Technical Skills

Backend Engineering

PythonFastAPIREST APIsAsync ProcessingSQLAlchemy ORMRequest HandlingCustom MiddlewareAPI DesignDebugging

AI Systems

OpenAI API/SDKRAGLangChainEmbeddingsSemantic SearchQdrantDocument ProcessingLLM OrchestrationPrompt Engineering

Databases & Infrastructure

PostgreSQLMySQLRedisKafkaDockerRenderVercelGitHubSwagger/OpenAPIPostman

Security & Auth

JWTOAuth2RBACRate LimitingRefresh Token RotationToken BlacklistingbcryptHTTPOnly CookiesReuse Detection

Software Engineering

OOPDSASystem DesignModular ArchitectureBackend ScalabilityGit WorkflowsStructured LoggingFault-Tolerant DesignRetry MechanismsSDLC
In Progress

Currently Building

  • Real-time log ingestion enhancements for AI Debugging Copilot
  • Distributed event-driven architecture patterns
  • Observability and monitoring workflows (Prometheus / Grafana)
  • Advanced backend engineering patterns
  • AI infrastructure and retrieval pipeline optimization
Get in Touch

Let's Connect

Open to the following roles:

Backend EngineerSoftware EngineerPython DeveloperAI Systems EngineerBackend AI Engineer