Open to SDE2 / SDE3 / SDE4 roles in product-focused teams and startups.

Backend heavy Full Stack Engineer | Scalable Systems · Real-time APIs · Cloud Infrastructure

Backend-focused full stack engineer with experience designing and shipping high-throughput APIs, event-driven systems, and cloud-native platforms for fast-moving product teams.

Focus areas: Distributed systemsReal-time APIsData-intensive backends
Architecture: Event-driven designDomain-driven modelingResilient integrations
Ways of working: Design docsProduction ownershipMetrics & observability

View engineering projects↓GitHub profile↗LinkedIn↗

Live AI chat

Ask anything about Rajkumar

Skills, projects, system design, experience — answers stream live from the backend AI service.

Engineering skill set

Depth across backend, systems, and production operations.

Backend Engineering

Depth

Designing predictable, maintainable backends that prioritize correctness, observability, and operational simplicity.

REST and RPC-style APIs with clear contracts and versioning
Async workers and background job pipelines
Performance profiling, hotspots analysis, and targeted optimization

Node.js · TypeScript · Go (working) · Python · gRPC

System Design & Architecture

Depth

End-to-end ownership from requirements to design docs, diagrams, and production rollout plans.

Event-driven and message-based architectures
Domain-driven design for complex product domains
Designing for graceful degradation and failure isolation

Event sourcing · CQRS (pragmatic) · Design docs · ADR

Databases & Storage

Depth

Schema design, query optimization, and data modeling for transactional and analytical workloads.

Modeling transactional systems with strong consistency guarantees
Indexing strategies and query optimization
Data migrations with minimal downtime and safe rollbacks

PostgreSQL · MySQL · Redis · MongoDB · S3-compatible stores

Real-time & Event-driven Systems

Depth

Building reliable, low-latency systems with predictable behavior under varying load.

WebSocket and long-polling APIs
Pub/sub messaging and fan-out patterns
Backpressure, rate limiting, and throttling strategies

Kafka · RabbitMQ · Redis Streams · WebSockets

Cloud & DevOps

Depth

Practical understanding of how code behaves in production — not just locally.

Containerized services with clear resource limits
Staging, canary, and blue/green deployments
Metrics, dashboards, alerts, and SLO-based thinking

Docker · Kubernetes (working) · AWS / GCP · Terraform · CI/CD

Frontend & Product Integration

Depth

Enough frontend depth to build reliable internal tools and production-ready user flows on top of strong backends.

API-first UI development with typed clients
State management for data-heavy dashboards
Performance-aware rendering and UX for complex workflows

React · TypeScript · Tailwind · SPA patterns

Featured engineering work

Production-grade systems focused on correctness and scale.

Selected projects that showcase backend depth, system design, and pragmatic scaling — not toy apps or UI clones.

Scalable Form Builder Platform

Lead backend & architecture

Backend-heavy

Problem: Product teams needed a way to ship complex, conditional forms without pushing new deployments for every change.
Architecture: Multi-tenant form engine backed by a schema-driven configuration store, with a versioned DSL for form definitions and a runtime evaluator.
Key challenges: Safely executing user-defined logic at scale · Keeping form rendering performant on low-end devices · Designing a migration strategy for evolving the form DSL
Scalability: Isolated tenants, rate-limited evaluation, and a cache layer for frequently accessed form definitions. Heavy use of read replicas for analytics queries.

Node.js · TypeScript · PostgreSQL · Redis · React

GitHub Demo

Real-time Notification System

Backend engineer

Backend-heavy

Problem: Existing system could not reliably deliver notifications across channels (email, push, in-app) with ordering guarantees and idempotency.
Architecture: Event-driven notification pipeline using a message bus, channel-specific workers, and a delivery log for idempotency and replay.
Key challenges: Guaranteeing at-least-once delivery without spamming users · Per-tenant rate limiting and quiet hours support · Tracing notification lifecycle end-to-end for debugging
Scalability: Horizontal scaling via partitioned topics, shard-aware workers, and bulk fan-out strategies. Backpressure and dead-letter queues for problematic events.

Node.js · Kafka · Redis · PostgreSQL · WebSockets

GitHub Demo

Subscription & Payment System

Backend engineer

Backend-heavy

Problem: Need for a robust subscription engine with proration, trials, discounts, and multiple payment providers.
Architecture: Isolated billing domain service that integrates with external payment gateways, exposes idempotent APIs, and maintains its own ledger for auditability.
Key challenges: Handling retries and webhooks without double-charging · Reconciling provider events with internal state · Designing a clear abstraction that allows swapping providers
Scalability: Queue-based webhook processing, batched reconciliation jobs, and a materialized view for customer billing overviews.

Node.js · PostgreSQL · Redis · Stripe / Braintree

GitHub Demo

Universal File Preview Platform

Full stack engineer

Backend-heavy

Problem: Teams needed a unified way to preview heterogeneous file types (documents, media, archives) in the browser without leaking sensitive data.
Architecture: Ingestion pipeline that normalizes files into a preview-friendly format, with signed URLs, access controls, and an isolated rendering sandbox.
Key challenges: Processing large files without blocking user requests · Securing previews for private and shared resources · Handling degraded previews when full fidelity is impossible
Scalability: Chunked uploads, background processing workers, and tiered storage. CDN cached previews for frequently accessed assets.

Node.js · S3-compatible storage · Lambda/workers · React

GitHub Demo

System design thinking

Pragmatic architectures for real-world constraints.

Short design snapshots for common product-critical systems — focused on trade-offs, failure modes, and operational realities.

Payment Systems

Correctness, idempotency, and auditability.

System design

Architecture overview: Designs payment flows as state machines with explicit transitions, isolating billing from core product logic and treating payment providers as external dependencies.
Scaling strategy: Queue-based webhook handlers, retry-safe APIs, and periodic reconciliation jobs to keep internal ledgers consistent with providers.
Bottlenecks: Provider latency, long-tail retries, and poorly modeled edge cases such as partial refunds and chargebacks.
Trade-offs: Balancing strict consistency in ledgers with eventual consistency in user-facing UIs, and deciding where to lean on provider abstractions versus custom logic.

Notification Systems

Multi-channel delivery with observability.

System design

Architecture overview: Separates notification intent (what happened) from delivery strategy (how, when, and where it is sent). Central event log with channel-specific workers.
Scaling strategy: Topic partitioning by tenant and channel, bulk fan-out workers, and per-channel rate limits with backoff strategies.
Bottlenecks: Third-party provider APIs, bursty traffic patterns, and poorly configured retries.
Trade-offs: Immediate delivery vs. batching, rich personalization vs. template reuse, and per-user vs. per-tenant rate limiting.

Chat Systems

Real-time performance with predictable costs.

System design

Architecture overview: Room-based architecture with WebSocket gateways, message fan-out via pub/sub, and a durable message store with pagination and search.
Scaling strategy: Sharded gateways, partitioned topics, and tiered storage for hot vs. cold conversations.
Bottlenecks: Hot rooms with high fan-out, presence tracking at scale, and reconnect storms after outages.
Trade-offs: Consistency vs. latency for message ordering, central vs. edge presence tracking, and indexing strategy for search.

Scalable APIs

Contracts, observability, and failure isolation.

System design

Architecture overview: API gateway fronting modular services, with strict schemas, typed clients, and consistent error and pagination models.
Scaling strategy: Horizontal scaling with stateless services, circuit breakers, and aggressive caching for read-heavy endpoints.
Bottlenecks: Downstream dependencies, N+1 patterns across services, and unbounded payload sizes.
Trade-offs: Coupling degree between gateway and services, monolith vs. service split, and synchronous vs. async boundaries.

Form Builder Platforms

Flexibility without sacrificing control.

System design

Architecture overview: Schema- and DSL-driven form engine with a runtime evaluator, clear versioning, and safe rollout of new capabilities.
Scaling strategy: Caching form definitions, precomputing validations, and using lightweight runtime execution sandboxes.
Bottlenecks: Complex conditional logic, nested repeatable sections, and cross-field dependencies.
Trade-offs: Expressiveness of the DSL vs. runtime complexity, central vs. client-side evaluation, and storage format evolution over time.

Experience

Operating in startup, consulting, and product environments.

Product engineering
Backend heavy full stack engineer
Recent
Working with early- to growth-stage product teams on critical backend-heavy initiatives.
- Owned backend architecture and implementation for greenfield products.
- Introduced design doc practices and production readiness checklists.
- Collaborated closely with founders, product, and design for fast iteration.
Early-stage startups
Founding / early backend engineer
Earlier
Joined lean teams as the primary owner of backend, infrastructure, and developer tooling.
- Shipped MVPs to production under tight timelines with pragmatic trade-offs.
- Instrumented critical paths with metrics, logging, and tracing from day one.
- Managed migrations, deployment pipelines, and on-call rotations.
Freelance & consulting
Backend & system design consultant
Parallel
Partnered with teams to diagnose scaling issues, redesign APIs, and simplify complex backends.
- Audited architectures, identified bottlenecks, and proposed concrete remediation steps.
- Created internal tooling to reduce operational overhead and manual work.
- Ran focused sessions on system design and production readiness.
Independent projects
Product and tooling builder
Ongoing
Building and iterating on internal tools, SaaS experiments, and infrastructure utilities.
- Exploring opinionated templates for backend-heavy SaaS products.
- Experimenting with observability and developer experience tooling.
- Documenting learnings in public where appropriate.

Engineering notes

Deep dives into scalability, correctness, and infrastructure.

A selection of topics that reflect how problems are approached — from APIs and payments to real-time systems and observability.

API scalability

Designing APIs that scale beyond the first client

Lessons from evolving APIs from one client and a handful of endpoints to multi-tenant, high-traffic systems without breaking consumers.

Versioning strategies · Pagination and filtering · Schema-first development

Draft topics — can be linked to a blog or docs.

Internal notes (no public link yet)

Payment systems

Payment idempotency in the real world

Practical patterns for making payment flows idempotent in the presence of retries, webhooks, and external provider quirks.

Idempotency keys · Retries · Webhooks · Reconciliation

Draft topics — can be linked to a blog or docs.

Internal notes (no public link yet)

Real-time systems

Architecting real-time features without over-complicating everything

How to choose between WebSockets, polling, and streams, and how to layer real-time features on top of existing products.

Transport choices · Backpressure · Operational costs

Draft topics — can be linked to a blog or docs.

Internal notes (no public link yet)

Infrastructure

Infra design for small teams with serious requirements

Designing infrastructure stacks that a small team can realistically operate while meeting uptime, latency, and compliance goals.

Cluster design · Deployment · SLOs · Runbooks

Draft topics — can be linked to a blog or docs.

Internal notes (no public link yet)

Contact