AI infrastructure, distributed systems, backend platforms

TamilArasan N

Backend Software EngineerAI SystemsDistributed ArchitecturePerformance Engineering
Building AI Systems.

I build backend systems that keep working when the load spikes, the model gets expensive, the queue backs up, and every millisecond starts to matter.

View ProjectsDownload ResumeGitHubLinkedInContact
prod-ai-platform

$ ssh tamil@infra-edge

$ export TRACE_ID=llm-run-42

$

workers: 8 online

queue: drained in 182ms

cache hit ratio: 94.7%

p95 latency: 28ms

API
healthy
LLM
streaming
Redis
hot
+ yrs
Experience
+
Projects
+
GitHub Repos
+
LeetCode
+
Years Coding
+ cups
Coffee
About

Systems first. Interfaces second. Reliability always.

The work is backend-heavy, but the instinct is product-minded: build the path that stays understandable after launch, after scale, and after the first unexpected failure.

I like building systems that continue working when everything else gets noisy: APIs under traffic, LLM pipelines with shifting outputs, queues under pressure, databases that need better indexes, and cloud infrastructure that has to be boring in production.

My engineering taste sits at the intersection of AI infrastructure, backend architecture, large-scale data processing, Linux operations, Dockerized deployments, Redis coordination, database design, and performance optimization. I experiment with Rust when the problem wants tighter control over memory, sockets, or throughput.

1

Design

Model the failure modes, data flow, ownership boundaries, and recovery path.

2

Build

Ship clean APIs, workers, queues, database paths, and observable services.

3

Measure

Use latency, cost, compression, memory, and throughput to guide the next iteration.

Experience

Production AI workflows, backend systems, and infrastructure.

The strongest work sits where product requirements meet orchestration, latency, databases, and deployment discipline.

flow trace

Distributed request path

Resume
ingest
LLM
reason
Redis
coordinate
Analytics
measure
Technical Skills

A backend stack organized like a system, not a checklist.

Languages, infrastructure, data stores, cloud, AI, and core computer science stay connected because production systems do not respect category boundaries.

Systems Core
LanguagesAIBackendInfrastructureDatabasesCloudDevOpsCore CS
Production

TypeScript

Backend services, API contracts, workflow orchestration, and type-safe product code.

Node.jsExpressNext.js
Featured Projects

Project work presented as architecture, tradeoffs, and measurable outcomes.

Each build is framed around the production problem, the system shape, the hard parts, and the performance signal.

LLM product architecture

AI Interview Platform

A production interview workflow needed to rank resumes, conduct spoken AI interviews, synthesize speech, and surface analytics without turning the backend into a fragile chain of one-off calls.

40%
Token savings
6
Pipeline stages
3
Realtime flows
TypeScriptLangChainLangGraphMongoDBRedisAWS
Resume parser
stage 01
Ranking model
stage 02
LLM graph
stage 03
Speech
stage 04
TTS
stage 05
Analytics
stage 06
Challenges
Deterministic orchestration around non-deterministic LLM responses.
Token budget control across ranking, interview, and feedback stages.
Low-latency state flow between user sessions, Redis, and persistent stores.
Data pipeline performance

1.5TB NDJSON -> Parquet Engine

A huge newline-delimited JSON dataset needed to become queryable without loading everything into memory or waiting on serial conversion work.

300M
Records
1.5TB
Input
16x
Compression
PythonParquetDuckDBWorkersCompression
NDJSON stream
stage 01
Workers
stage 02
Compression
stage 03
Parquet
stage 04
DuckDB
stage 05
Challenges
Streaming 300M records with bounded memory.
Parallel conversion without corrupting row groups or starving I/O.
Keeping the final dataset compact and fast to query.
Network and latency engineering

High Performance HTTP Audio Server

Audio workloads needed predictable request handling, socket-level control, and tight latency under concurrent traffic.

0.68ms
Latency
Realtime
Streams
Yes
Profiled
RustHTTPSocketsProfilingLinux
Clients
stage 01
HTTP server
stage 02
Socket layer
stage 03
Audio stream
stage 04
Metrics
stage 05
Challenges
Reducing latency spikes from connection churn.
Keeping throughput stable under concurrent streams.
Measuring the server as a system rather than isolated handlers.
Cloud operations

Infrastructure and VPS Platform

Projects needed reliable deployment paths, repeatable environments, monitoring, and fast operational recovery on pragmatic infrastructure.

Automated
Deployments
Docker
Runtime
Linux
Ops
DockerLinuxNginxGitHub ActionsAWS
GitHub
stage 01
CI/CD
stage 02
Docker
stage 03
VPS
stage 04
Nginx
stage 05
Monitoring
stage 06
Challenges
Making deploys reproducible across local and remote environments.
Hardening Linux services without overcomplicating the stack.
Keeping logs, metrics, and rollback paths close to the developer loop.
Engineering Dashboard

A monitoring view for the engineering signal behind the portfolio.

Stats, languages, architecture strengths, and coding activity are presented as operational telemetry rather than vanity counters.

Coding Activity

Languages

Architecture Skills

GitHub Stats
42 repositories
LeetCode Stats
320+ problems
Recent Commits
84 this month
System Design
queues, caches, DBs
Tech Stack Visualization

A stack graph that follows request flow instead of icon walls.

The graph connects application code, cache, databases, cloud, containers, operating systems, and LLM orchestration as one delivery path.

active node
TypeScript
Architecture Playground

An interactive distributed system map with live request motion.

Click any component to inspect its role in a backend architecture built around APIs, queues, workers, Redis, LLM graphs, databases, and object storage.

component

Users

Authenticated browser sessions, realtime interview flows, dashboards, and API clients.

latency budgettracked
failure boundarytracked
observabilitytracked
scale pathtracked
Blog

Writing topics for people who like the engineering beneath the product.

Distributed systems, AI agents, databases, backend design, Rust, Linux, performance engineering, and architecture notes.

Performance

Processing 1.5TB of NDJSON on a Potato Laptop with Rust

Streaming conversion, compression tradeoffs, worker pools, Parquet, and DuckDB query paths on low-end hardware.

Read article
Achievements

Numbers that describe scale, compression, latency, and cost control.

K+
Production users
M
Records processed
TB
Data pipeline scale
x
Compression wins
%
Token savings
x
Query performance
ms
Latency target
Contact

Let's build something incredible.

/contact/tamil

> open channel

role: backend + AI systems engineer

focus: reliability, latency, scale, architecture

> Ready for serious systems work.

tamilarasan.n.dev@gmail.comLinkedInIndia