Software Development Senior Specialist @ NTT DATA

Architecting Agentic AI, Resilient Cloud & High-Scale Python Systems.

Senior Software Engineer with 6+ years of full-stack craftsmanship, enterprise AI orchestration with LangGraph & RAG, and production platform engineering across AWS & Azure. Designing deterministic software guardrails around probabilistic AI models.

6+
Years Production Eng
LangGraph
Agent Workflows & RAG
AWS & Azure
Production Platform Ops
Global
Enterprise Client Delivery
node://production-agent-mesh
HEALTHY
ENGINE_ROLE: Senior AI / Platform Engineer
CORE_RUNTIME: Python 3.12+ | FastAPI | LangGraph
ORCHESTRATION: Stateful Agents • Tool Calling • RAG
STORAGE_MESH: RDS Postgres • FAISS • Graph DBs • Redis
CLOUD_POSTURE: AWS VPC / IAM / CloudWatch • Azure CI/CD
SECURITY_GUARD: Okta PKCE / OIDC • Trivy Scanned • SSM
SYSTEM_AVAILABILITY: Open to Senior / Staff Roles
Production Readiness & Security Audits 100% Passed
> agent.compile(checkpointer=MemorySaver(), guardrails=DeterministicRules())

How I Architect Production Systems

Click across the tabs below to inspect three real architectural paradigms I have engineered in enterprise production environments. Click each node to see design decisions.

LangGraph Agentic SDLC & Requirements Engine
Click any node to inspect technical implementation details
NODE INSPECTOR

Select a node from the diagram

Click on any component above to inspect its real-world implementation, trade-offs, and technologies used in production.

Deterministic Multi-Agent Systems in Production

An in-depth 8-minute architectural walkthrough: closing the gap between probabilistic LLMs and deterministic enterprise systems with LangGraph, schema guardrails, and resilient cloud microservices.

stream://deterministic-ai-architecture.mp4
4K EXPLAINER • 07:52 MIN
Deterministic Agentic State Machines
INTERACTIVE CHAPTERS Click to jump
100% Deterministic
<150ms FAISS Vector RAG
N = 3 Recursion Bound

The Engineering Journey

From full-stack development to architecting enterprise-scale AI platforms and cloud platforms.

Sep 2025 — Present NTT DATA Information Processing Services Global Enterprise Delivery
Current Role

Software Development Senior Specialist

Architecting and engineering production GenAI agentic workflows, cloud platform infrastructure on AWS, and high-performance Python microservices for Fortune 500 clients.

Agentic SDLC & LangGraph: Orchestrated multi-agent graphs for RFP-to-BRD generation, RAG retrieval using FAISS/graph databases, and tool integration.
AWS Production Platform (DENSO): Hardened production cloud infrastructure across VPC, RDS PostgreSQL, ElastiCache Redis, EFS, SSM, and CloudWatch. Conducted Trivy vulnerability scans and container remediation.
Modern Microservices (Munich Re): Built FastAPI / Python 3.12 microservices replacing legacy Java workflows; integrated Azure AD OIDC and Azure DevOps CI/CD.
Enterprise Security: Implemented Okta OIDC Authorization Code Flow with PKCE, multi-language localization (Japanese, Traditional Chinese), and secrets management.
Python 3.12 FastAPI LangGraph RAG AWS (VPC/RDS/SSM) Azure DevOps Okta PKCE Trivy
2023 — 2025 Maaze Underwriting Solution Pvt. Ltd.

Python Developer

Engineered backend underwriting APIs, schema architecture, and database optimizations for insurance domain applications with high data consistency requirements.

Data Modeling & APIs: Built robust Django and Django REST Framework backends, designing complex database schemas and handling complex policy lifecycle logic.
PostgreSQL Performance: Optimized query execution plans, refined database indexes, and resolved concurrency bottlenecks in high-volume underwriting calculations.
Client Delivery & Mentorship: Collaborated directly with domain underwriters to translate underwriting rulebooks into deterministic software logic, mentoring junior developers.
Python Django Django REST Framework PostgreSQL REST APIs SQL Optimization
2020 — 2023 MateBench Software Pvt. Ltd.

Software Engineer

Built full-stack applications in banking and logistics domains, connecting reactive frontend interfaces with secure, reliable Python backend microservices.

Full-Stack Integration: Developed responsive interfaces in React/JavaScript coupled with Django backends for financial workflow management.
Resilient Integrations: Built third-party payment and logistics API adapters, automated unit testing with pytest, and established secure session handling.
Python Django React JavaScript MySQL / Postgres Unit Testing

Production Case Studies

Detailed breakdowns of architecture, technical constraints, security measures, and real outcomes.

Agentic AI & Platform
PROJ-01

Tesseract Forge — LangGraph Agentic SDLC & BRD Pipeline

An enterprise-scale agentic platform built to automate requirements engineering. Uses LangGraph to orchestrate stateful agents that parse Request for Proposals (RFPs) and synthesize structured Business Requirement Documents (BRDs).

Architecture LangGraph state machine with cyclic checks, tool-calling nodes, and hybrid FAISS + Graph retrieval.
Security & Auth Okta OIDC Authorization Code Flow with PKCE for enterprise SSO.
Localization Resolved complex Japanese & Traditional Chinese encoding and layout rendering constraints.
Observability Integrated AWS CloudWatch and SSM access for production debugging and latency tracking.
Cloud Platform & DevOps
PROJ-02

DENSO Hyper Intelligence — AWS Production Platform Readiness

End-to-end production readiness, security hardening, and infrastructure architecture for an enterprise automotive intelligence platform deployed on AWS.

Networking & Topology VPC architecture with multi-tier isolated subnets, NAT Gateways, and strict Security Group rules.
Data Tier Configured Amazon RDS PostgreSQL with automated failover, ElastiCache Redis clustering, and EFS.
Security & Vulnerabilities Container image vulnerability scanning with Trivy, Dockerfile hardening, and AWS Secrets Manager.
Reliability IAM least-privilege policies, AWS Backup retention schedules, and CloudWatch alarm matrices.
Modern Microservices
PROJ-03

Munich Re — IFRS 17 Movement Analysis Engine

Re-engineered critical actuarial calculation and movement analysis services from legacy Java post-processing to a high-speed Python 3.12 / FastAPI microservice architecture.

Modern Backend FastAPI, Pydantic v2 validation models, and SQLAlchemy ORM interacting with PostgreSQL.
Identity & CI/CD Azure Active Directory OIDC authentication, Swagger OAuth2, and automated Azure DevOps pipelines.
Deployment Production delivery to hardened external Windows application servers managed via NSSM Windows services.
Hybrid AI Architecture
PROJ-04

GenAI Innovation Centre — Retail Loan Credit Analyst Engine

Architected an explainable retail loan origination engine that combines deterministic financial computation with local LLM document reasoning.

The Architecture Rule Zero LLM arithmetic: 100% deterministic Python rules for EMI and Debt-to-Income (DTI) calculations.
Local LLM & FAISS Integrated Ollama running local models with FAISS vector search to extract qualitative applicant signals.
Verification & Test FastAPI + Streamlit full-stack prototype validated with 100% test coverage using pytest.
Application Engineering
PROJ-05

TalkTrack — Multimodal AI Experience & Release Engineering

End-to-end testing, usability stabilization, and production release engineering for a high-touch AI application spanning mobile and desktop platforms.

Multimodal Debugging Diagnosed and resolved edge-case camera capture, OCR extraction, and memo synchronization issues.
Data Integrity Fixed state navigation errors, record deletion lifecycles, and search/filter caching bottlenecks.
FinTech & High-Consistency
PROJ-06

Maaze — High-Throughput Insurance Underwriting Core

Core policy assessment APIs handling complex underwriting decision trees and multi-table relational persistence.

Database Optimization Refined PostgreSQL schema migrations, indexes, and execution plans to prevent transaction deadlocks.
API Design RESTful Django REST Framework endpoints with strict validation and granular access controls.

The Engineering Arsenal

Tools and paradigms verified through 6+ years of real production implementations.

Agentic AI & LLM Systems

Stateful orchestration, retrieval-augmented generation, and guardrails.

LangGraph RAG Pipelines Agent Tool Calling FAISS / Vector DBs Graph Databases Ollama / Local LLMs Memory Architectures Model Evaluation Prompt Engineering MCP Integrations

Backend & Microservices

High-speed Python APIs, relational persistence, and full-stack integration.

Python (FastAPI, Django) PostgreSQL SQLAlchemy / Pydantic Django REST Framework Flask React / JavaScript Redis Caching MySQL pytest (TDD) Microservice Design

Cloud, Platform & DevOps

Production infrastructure, containerization, and automated pipelines.

AWS VPC & Networking RDS PostgreSQL AWS ElastiCache AWS CloudWatch & SSM AWS Secrets Manager AWS IAM & Backups Azure DevOps CI/CD Docker Containerization Trivy Security Scanning Git / GitHub / GitLab

Identity, Security & SDLC

Enterprise authentication protocols and delivery rigor.

OAuth 2.0 & OIDC Okta Authorization Code + PKCE Azure AD Integration Container CVE Remediation RFP-to-BRD Synthesis Client Technical Delivery Japanese/Chinese Localization

The Engineering Creed

How I approach software architecture, AI reliability, and enterprise platform delivery.

01

Deterministic Math, Probabilistic Reasoning

LLMs should never calculate interest rates, financial ratios, or critical validation gates. We construct rigid, deterministic rule engines (in Python/Pydantic) for facts and constraints, using AI strictly for semantic extraction, synthesis, and human-facing explanation.

02

Observability Precedes Production

A system you cannot observe is a liability. Every LLM node, database transaction, and API endpoint must have structured logging, latency tracking, CloudWatch metrics, and fallback states before it is considered ready for deployment.

03

Security by Architecture, Not by Checklist

Least privilege IAM roles, isolated private subnets with no public ingress for RDS and Redis, automated Trivy scanning in CI/CD, and PKCE-enforced OIDC tokens. Security is built into the topology, not patched on at the end.

04

Clear Interfaces & Schema Integrity

Strong boundaries prevent system decay. Whether it is a LangGraph state dictionary, a FastAPI Pydantic schema, or a database migration, explicit contracts make systems maintainable across international engineering teams.

Terminal Access

Interact with my background directly from the command line. Try typing help.

rajat@production-mesh:~ (zsh)
UTF-8
Rajat Patle Engineering Terminal v2.4 (Production AI & Systems Edition)
Type help to view all commands, or click any command below:
guest@rajat-arch:~$
Available for Senior / Staff Engineering Roles

Let's Build Scalable, Production-Ready Systems.

Looking for a Senior Software Engineer, AI Architect, or Platform Engineer who bridges cutting-edge agentic AI with rigorous production cloud infrastructure? Let's connect.

✓ Specializations: Senior AI Engineer, Senior Software Engineer (Python), Full Stack & GenAI, Platform Engineer
✓ Engineering Track: 6+ years across enterprise microservices, cloud deployments, and agentic workflows
✓ Work Mode: Open to Remote, Hybrid & On-Site Roles
✓ Languages: English (Fluent), German (A1), Hindi (Native), Marathi (Native)

Direct Engineering Inquiries

Exploring senior roles in AI, Cloud, or Python systems? Send an inquiry or request my tailored CV.

Email Interview Inquiry
• Core Architectural Standard
Deterministic guardrails, production observability before deployment, and zero compromise on code craftsmanship.