Naman Mahna
London, United Kingdom · Software Engineer
Coventry University
8 followers
About
Software Engineer with 3.5 years of experience building and supporting backend services, APIs, and full-stack applications. Strong background in Python, FastAPI, Node.js, TypeScript, PostgreSQL, Redis, asynchronous processing, testing, and CI/CD, with experience delivering reliable business systems and cloud-native platforms.
Specialties
- AWS Security
- Penetration Testing
- Security Engineering
Skills
- Python
- TypeScript
- JavaScript
- SQL
- LLM Applications
- Agentic AI
- RAG
- Prompt Engineering
- Tool Calling
- AI Guardrails
100 skills in total
Experience
-
Software Engineer
SoftSensor AI
Jul 2022 — Jan 2025
Jaipur, Rajasthan, India
-
Frontend Developer
Creative Web Pixel
Mar 2021 — Jan 2022
Jaipur, Rajasthan, India
Education
-
Coventry University
Master's degree, Cyber Security
Jan 2025 — Jan 2026
-
SKIT Jaipur
Bachelor's degree, Computer Science
Aug 2013 — Jul 2017
Repositories
-
namanmahna2/dcms-python-microservice
A Python-based microservice built with FastAPI for the Decentralized Credential Management System (DCMS). Handles credential verification, anomaly detection, and secure data processing. Integrates with REST APIs, Redis queues, and messaging for asynchronous workflows, supporting scalable, containerized deployment in a distributed system.
Python
-
namanmahna2/dcms-backend
Node.js backend service for the Decentralized Credential Management System (DCMS). Provides RESTful APIs for credential issuance, verification, and access control, with JWT-based authentication, role-based permissions, Redis queues for asynchronous processing, and integration with blockchain and Python microservices. Designed for secure, scalable,
JavaScript
-
namanmahna2/dcms-frontend
React-based frontend for the Decentralized Credential Management System (DCMS). Provides role-based dashboards for credential issuance, verification, and management, integrating with backend APIs and blockchain services. Designed with a responsive, user-focused interface and secure authentication flows.
JavaScript
-
namanmahna2/dcms-blockchain
Ethereum-based smart contracts for the Decentralized Credential Management System (DCMS). Implements secure issuance, verification, and revocation of credentials using ERC-721 standards, providing immutable audit trails. Built with Solidity and Hardhat, with role based access, testing, and deployment scripts for production-ready blch. integration.
HTML
Recent posts
**🚀 Rate Limiting Microservice | Update #1: Building a Distributed, Policy-Driven Rate Limiting System**
Over three weeks, I’ve built an independent service to centralise rate-limit enforcement across applications and API gateways, with configurable, identity-aware decisions and concurrency-safe state management.
**WHAT I HAVE ENGINEERED**
**1. Four rate-limiting algorithms**
• Fixed Window Counter tracks request counts and window start times.
• Sliding Window Log stores timestamped entries in a Redis Sorted Set; expired entries are removed by score before evaluating the active window.
• Token Bucket maintains token balance and update time, with time-based replenishment.
• Leaky Bucket maintains water level and update time, with time-based leakage and capacity enforcement.
**2. Atomic Redis state management**
Redis Hashes hold Fixed Window, Token Bucket and Leaky Bucket state; a Sorted Set stores Sliding Window Log timestamps. Lua scripts run via EVAL perform reads, time calculations, quota checks and mutations atomically preventing concurrent requests from interleaving decision and update. Redis server time and PEXPIRE provide reliable timing and state expiry.
**3. Database-backed policy engine**
FastAPI, asynchronous SQLAlchemy and PostgreSQL underpin client-specific policies resolved by resource, HTTP method, route, identity type and quota scope. Exact routes take precedence over wildcard fallbacks; policies select the algorithm, its configuration and per-identity or shared quota scope.
**4. Service authentication and authorisation**
Credentials use an ID and a cryptographically generated secret (secrets). HMAC-SHA256 with a server-side key derives the verifier, checked using constant-time comparison. Credential controls include key version, activation, not-before, expiry and revocation. The authenticated service identity is then checked against its assigned permissions.
**5. End-to-end decision pipeline**
The API validates, authenticates and authorises each call, resolves a policy, builds a namespaced Redis key and dispatches its Lua script. The result is normalised into an allow/deny response with remaining quota and retry timing.
**TECHNOLOGY STACK**
Python 3.14, FastAPI, Pydantic, async SQLAlchemy, PostgreSQL/NeonDB, Redis/Lua, Alembic, Docker, Kubernetes/K3s, Helm, Kubernetes Secrets, Pytest, Ruff, MyPy, Locust, Prometheus and Grafana.
**WHAT’S NEXT**
Concurrency, load and security testing, including penetration testing, then benchmarking.
I am integrating the service with Kong API Gateway in my separate AI DevOps project. Kong requests a centralized rate-limit decision before forwarding upstream. Integration is ongoing.
Next: architecture diagrams, low-level design, integration and test results
**Repository**: https://github.com/namankali/rate-limiting-service
#Python #FastAPI #Redis #PostgreSQL #BackendEngineering #DistributedSystems #Microservices #Kubernetes #CloudNative #PlatformEngineering #APIManagement #PythonDeveloper #BackendDeveloper #CloudEngineering #SystemDesign
☁️ AI DevOps Copilot — Building an AI-Powered, Cloud-Native DevOps Platform
What if a DevOps platform could do more than display dashboards—what if it could help engineers investigate failures, understand operational dependencies, and make troubleshooting more intelligent?
That question has been driving the development of my AI DevOps Copilot, a full-stack platform that brings together AI-assisted troubleshooting, CI/CD observability, Kubernetes infrastructure insights, and event-driven incident analysis.
🤖 1. AI-Powered DevOps Assistant
The AI layer uses multiple execution paths rather than relying on a single RAG workflow. Based on user intent, it can:
▪️ Handle conversational queries
▪️ Execute live tools against DevOps and GitHub data
▪️ Retrieve and analyse historical CI/CD failure context through RAG
GitHub Actions logs are processed to extract meaningful failure information, which is transformed into searchable knowledge using Sentence Transformers, embeddings, and Qdrant.
The architecture combines intent classification, live tool execution, historical context retrieval, guardrails, and LLM-generated responses to support more context-aware troubleshooting.
⚙️ 2. Event Engine & Pipeline Intelligence
I’ve also been developing an Event Engine that transforms CI/CD workflow events into pipeline state, performance metrics, and dependency-aware incident insights.
Key engineering implementations include:
▪️ Pipeline State Management — Tracks CI/CD activity using repository and workflow identifiers.
▪️ Sliding Window Event Processing — Uses Python’s collections.deque with a two-hour development window to manage recent events and expire stale data efficiently.
▪️ Percentile Metrics with an Augmented AVL Tree — Uses order-statistic operations to calculate P50, P70, P90, P95, and P99 execution-duration percentiles, providing a more detailed view of pipeline performance than averages alone.
▪️ Severity-Based Incident Processing — Classifies operational events and prioritises failures based on severity.
▪️ Runtime State Recovery — Restores recent pipeline state and dependency topology during startup.
▪️ Deployment Target Mapping — Connects repositories, workflows, and branches to their configured Kubernetes clusters and services.
▪️ Dependency-Aware Impact Analysis — Uses Kubernetes service dependency graphs, adjacency structures, and reverse-adjacency traversal to identify potentially affected downstream services.
The objective is to connect CI/CD events with infrastructure relationships and provide more useful context when investigating operational failures.
📊 3. Full-Stack DevOps Platform
The platform brings together several operational views:
▪️ Dashboard: Repository, build, deployment, and AI health insights.
▪️ CI/CD: Workflow runs, jobs, branches, failures, success rates, and execution durations.
▪️ Kubernetes: Visibility into workloads, services, networking resources, configuration, storage, events, and resource usage.
▪️ AI Assistant: An interactive interface combining live operational data with historical failure context.
▪️ AI Health: Monitoring dimensions including provider and model availability, inference success, latency, and tool reliability over a 24-hour window.
🛠️ Technology Stack
Frontend: React, Vite, TypeScript
Backend: Node.js, TypeScript
Database: PostgreSQL
Asynchronous Processing: Redis, Bull
AI Services: Python, FastAPI
LLMs: Ollama (local), OpenAI API
Vector Database: Qdrant
Infrastructure: Docker, Kubernetes, K3s, AWS EC2
The platform currently runs across my local Kubernetes environment and AWS EC2-based K3s infrastructure.
🔐 4. Reliability, Security & What’s Next
The next phase focuses on strengthening the platform through:
▪️ Concurrency validation and load testing
▪️ Improving event-processing reliability and recovery behaviour
▪️ Continuous security testing and penetration testing across APIs, infrastructure, containers, and exposed interfaces
▪️ Further development of AI-assisted troubleshooting and operational reasoning
▪️ Progress towards an AWS EKS deployment
The broader engineering challenge is to make these components work together reliably—not simply to add AI to an existing dashboard.
For me, this project is about combining data structures, backend engineering, AI, infrastructure observability, and security into a platform that can help engineers move from detecting an operational problem towards understanding its context and potential impact.
More to come. 🚀
#AIDevOps #DevOps #AI #PlatformEngineering #SoftwareEngineering #Kubernetes #AWS #Python #FastAPI #DistributedSystems #Observability #CyberSecurity #DevSecOps