Backend Engineer & Cloud-Native Developer
Ritik
Mehra
Hey there! I started coding in 2021 and haven't stopped since.
Want to see how it all went down?
Where It All Began
Dec 2021 - Jun 2022 Hyderabad (Hybrid)
EdTech platform for online courses and assessments. I handled payments, certificate generation, and video delivery — the infrastructure that kept the classroom running.
Payment Gateway Integration
Problem: EdTech platform needed secure, real-time payment processing for course fee management with live notifications to students and admins.
Solution: Integrated Cashfree payment gateway with webhook handlers for real-time payment status updates, idempotent processing to prevent duplicate charges, and signature verification for webhook security. Built stored procedures in MS-SQL for fee management with live notifications tied to payment events.
PDF Rendering Engine
Problem: Server-side PDF generation for certificates and progress reports was blocking the Node.js event loop under concurrent load, with no access control on generated documents.
Solution: Enhanced Puppeteer-based rendering with JWT token authorization — users only access their own documents. Implemented a queue-based generation system to handle concurrent requests without blocking the event loop, ensuring reliable certificate and report delivery.
Vimeo + Azure Blob Storage
Problem: Local file storage didn't scale horizontally for growing video content, and there was no access control for sensitive educational materials.
Solution: Integrated Vimeo Upload API with domain whitelisting for secure video hosting and playback. Migrated file storage to Azure Blob with SAS tokens for time-limited, secure access. Stored video metadata in MS-SQL with proper indexing for fast retrieval across courses.
What I Learned
Webhooks, queues, async processing, secure document delivery — production engineering across the full stack in six months.
Finding My Feet
Aug 2022 - Nov 2023 Gurgaon (Hybrid)
Tech consultancy solving problems for global clients. I built backend systems across multiple projects — improved performance by 40% through better caching, database optimization, and cleaner architecture.
Backend Performance Engineering
Problem: Single-threaded Node.js wasn't utilizing all CPU cores. Connection overhead was high. Callback hell made error handling unreliable.
Solution: Used the Cluster module to utilize all CPU cores. Implemented connection pooling — reusing persistent connections reduced overhead by ~60%. Replaced callbacks with async/await throughout. Added request validation middleware at the API gateway — bad requests rejected before business logic.
Database Optimization
Problem: Slow queries, full table scans, N+1 query problems, and inefficient data models were bottlenecks.
Solution: Designed normalized schemas with FK constraints. Created composite indexes — queries dropped from 200ms to 15ms. Implemented cursor-based pagination for scale. For MongoDB: denormalized schemas for reads, built aggregation pipelines for reporting, added TTL indexes for auto-cleanup.
Code Quality & Architecture
Problem: Monolithic route handlers, duplicated logic, inconsistent patterns. Onboarding took 2 weeks.
Solution: Refactored into layered architecture: Controllers → Services → Repositories. Extracted shared middleware for logging, error handling, rate limiting. Applied OOP: inheritance for base models, composition for shared behaviors, strategy pattern for pluggable payment processors.
What I Learned
Cluster modules, connection pooling, layered architecture, composite indexes — backend engineering from the database up.
Going Global
Nov 2023 - Mar 2025 Toronto (Remote)
SaaS platform helping creators and small businesses grow through community tools. I built and scaled the core products — MembersPod and SME GrowthHub — handling real-time engagement and AI features.
Real-Time Engagement Engine
Problem: Users needed real-time interactions across multiple Spaces without broadcast noise overwhelming the system.
Solution: Built room-based Socket.io — users only receive events for their spaces (80% noise reduction). Real-time push for online users, Redis queue + cron fallback for offline. Feed systems via pub/sub — events to Redis channels, consumed by feed service. Connection management: reconnection, heartbeat, WebSocket-to-long-polling fallback.
API Performance Optimization
Problem: Feed APIs triggered 50+ DB queries per request (N+1). No caching. Uncompressed payloads.
Solution: Multi-layer caching: Redis for hot data, CDN for static, in-memory for config. Event-driven cache invalidation. Fixed N+1 with eager loading — 50 queries → 3. Added composite indexes, EXPLAIN ANALYZE for slow queries. Cursor-based pagination. gzip/brotli compression reducing payloads 60-70%.
AI Integration & Analytics
Problem: Needed personalized content, automated reporting, and admin tools to reduce manual work.
Solution: OpenAI API for behavior-based content scoring and recommendations. Rate limiting with batching and 24-hour caching. Gamification: points system (10/post, 5/comment, 50/event), Redis sorted sets for O(log N) leaderboards. Admin panel with AI-powered reports. Jira-like task management with sprints, backlog, burndown charts.
What I Learned
Socket.io rooms, Redis pub/sub, eager loading, OpenAI scoring — real-time SaaS engineering at global scale.
Leveling Up
Jun 2025 - Present Netherlands (Remote)
Trading platform with real-time analytics, on-chart execution, and AI-powered insights. I built the microservice architecture — data feeds and indicator services processing in milliseconds.
Microservices Architecture
Problem: Trading platform needed separate, scalable services for data ingestion, indicator computation, and AI charting.
Solution: Built microservices with single responsibilities: Datafeed Service ingests real-time market data from multiple sources (crypto, forex, equities) and normalizes it. Indicator Service computes technical indicators (RSI, MACD, Bollinger Bands) on streaming data. AI Charting Service does pattern recognition — support/resistance, trend lines, candlestick patterns.
QuestDB Time-Series Database
Problem: PostgreSQL/MongoDB could not handle millions of market data points per second with sub-millisecond query performance.
Solution: Implemented QuestDB — columnar storage optimized for write-heavy append-only time-series. Sub-millisecond range queries. Built-in ASOF JOIN for cross-source timestamp alignment. Data pipeline: Exchange API → Message Queue → Datafeed → QuestDB → Indicator Service → WebSocket. Backpressure handling with queue buffering.
Low-Latency System Optimization
Problem: Traders need real-time data with minimal latency — every millisecond matters for trading decisions.
Solution: Binary protocols instead of JSON for internal communication. Zero-copy data passing where possible. Batch processing for indicator computations. Incremental computation — update on new data, don't recalculate. High-throughput WebSocket endpoints handling thousands of concurrent connections with multiplexing. Rate limiting at API gateway.
What I Learned
QuestDB, microservices, zero-copy, binary protocols — low-latency trading systems from data feed to chart.
Beyond the Code
The Arsenal
J
T
N
P
G
GThe Creations
NeuralCart
Full-stack e-commerce platform with microservices orchestration, Elasticsearch full-text search, pgvector + Ollama AI recommendations, Prometheus/Grafana observability, and CI/CD pipelines
ScaleCraft
Distributed systems lab: NGINX reverse proxy, Redis distributed cache with stampede prevention, rate limiting, Prometheus/Grafana observability — 9,146 req/s throughput on a single machine
KrakenKafka
Real-time market data pipeline: ingests live crypto trades from Kraken WebSocket API, streams through Apache Kafka, and delivers to connected clients via WebSocket server
AutoBlog AI
Enterprise-grade AI content generation with 6 specialized personas, multi-agent workflow (writer, reviewer, editor, verifier), quality gates, and automated publishing to Twitter & Dev.to
What's Your Story?
Your message has been delivered successfully.
I will respond promptly.
What I've Learned
Backend engineering and cloud-native development. I design and build scalable APIs, microservices architectures, and robust distributed systems. My core stack is Node.js, TypeScript, PostgreSQL, Docker, and Kubernetes — but I pick up whatever tools the job demands. I care about performance, observability, and building systems that don't wake you up at 3 AM.
5+ years working with companies across the globe — Vuetra in the Netherlands (AI-powered trading platform), Apollofy in Toronto (SaaS with real-time engagement), Antino Labs in India (tech consulting), and more. I've been fully remote for most of my career, so I know how to collaborate across time zones, write clear documentation, and ship independently.
Yes! I'm actively looking for my next role. I thrive in remote environments and love working with teams that value clean architecture, performance, and developer experience. If you're building something interesting — especially in backend, cloud infrastructure, or real-time systems — let's talk.
Start simple, then scale intentionally. I focus on clean architecture first — proper separation of concerns, well-defined API contracts, and testable business logic. For databases, I match the tool to the access pattern (relational for structured data, document for flexible schemas, time-series for streaming data). I always think about caching strategies, rate limiting, observability, and graceful degradation from day one. Performance isn't an afterthought — it's a design constraint.
I'm a gamer at heart — FPS, RPGs, strategy games, you name it. I also spend time solving coding problems on LeetCode and reading technical blogs, architecture deep-dives, and RFCs. I genuinely enjoy this stuff, so the line between work and hobby is pretty blurry.