Engineering CloudSystems Built for Scale.
I'm Rishab Sharma, an AWS Backend Engineer specializing in cloud architecture, distributed systems, scalable APIs, and production infrastructure — from real-time IoT pipelines to queue-driven microservices.
Cloud engineering
is my identity.
AWS Backend Engineer & Full-Stack JavaScript Developer with 3+ years building scalable cloud applications, distributed processing systems, and modern React/Next.js frontends. React exists here because I ship complete products — but the backend is where the value lives.
Bachelors in Information Technology (BIT)
Herald College Kathmandu
May 2019 — Jun 2022 · First Class Honours
Experience
3+ Years
Building production cloud systems
Backend
NestJS · Node · Python
Microservices & APIs
Cloud
AWS
Serverless & containers
Infrastructure
Docker · IoT
Distributed systems
Databases
Mongo · Postgres · DynamoDB
SQL & NoSQL
Frontend
React · Next.js
Complete products, end to end
How I think about building systems.
A few principles that shape every architecture decision I make.
Scalable software starts with simple architecture.
Complexity is a cost. I reach for the simplest design that satisfies the requirement, then let it grow only when the system earns it.
Performance isn't an optimization. It's a feature.
Latency and throughput are part of the product experience. I design for them up front — queues, caching, and query shape — not as an afterthought.
I build systems that keep working long after deployment.
Containerized services, background workers, and observability mean the system stays healthy in production, not just on my machine.
Measurable engineering over unnecessary complexity.
I prefer decisions I can justify — clear boundaries, predictable data flow, and infrastructure that a team can reason about.
A track record in cloud & backend.
Roles building serverless platforms, IoT pipelines, and production APIs across the AWS ecosystem.
Production systems, end to end.
Selected work spanning multi-tenant SaaS, distributed job processing, full-stack platforms, and headless CMS builds.
01 · Multi-tenant SaaS ticketing platform
OpenTickets
Problem
Multiple clients needed isolated ticketing environments with dedicated admin portals — without standing up separate infrastructure for each tenant.
Solution
A scalable, multi-tenant SaaS platform where every client gets a dedicated admin portal, backed entirely by serverless AWS primitives and real-time GraphQL.
- Multi-tenant architecture supporting multiple clients with dedicated admin portals.
- Backend logic on AWS Amplify with Lambda functions in Python and Node.js.
- DynamoDB for high-performance storage; GraphQL via AppSync for real-time fetching.
- CI/CD managed with the AWS Amplify CLI for seamless deployment.
02 · Queue-driven bulk email at scale
Bulk Email Processor
Problem
Sending thousands of emails synchronously overloads the server and blocks the request lifecycle.
Solution
A high-performance sending system that offloads work to background queue workers, so the API stays responsive while thousands of emails are processed reliably.
- Upload an Excel/CSV list and choose an email template.
- Emails dispatched automatically in the background via BullMQ + Redis job queues.
- Queue workers keep the server from overloading under heavy volume.
- Real-time job status and progress tracking.
03 · Library management with admin dashboard
Page Pavilion
Problem
Libraries need automated borrowing workflows and secure administration alongside a clean public experience.
Solution
A full-stack library system with a public-facing app and an admin dashboard, featuring automated workflows, caching, and secure auth.
- Public-facing application plus a dedicated admin dashboard.
- Automated book borrowing, reminders, and receipts with robust user management.
- Redis caching for optimized performance and scalability.
- Secure authentication via Auth.js.
04 · Healthcare scheduling with voice assistant
Hospital Management System
Problem
Manual appointment scheduling and patient data handling slow down clinical operations.
Solution
A Django-based hospital management system with a voice assistant integration that streamlines scheduling and patient data management.
- Voice assistant feature built on the Google Calendar API.
- MySQL-backed patient data management.
- Streamlined appointment scheduling for improved operational efficiency.
05 · Real estate listing platform
MERN Real Estate
Problem
A property marketplace needs responsive listings with secure data flows and efficient state handling.
Solution
A comprehensive real estate application on the MERN stack with responsive UI, RESTful APIs, and Redux-driven state.
- Responsive React UI with RESTful APIs built in Express.js.
- Efficient data management across the stack.
- Redux for secure data transactions and improved interactions.
06 · Official event website
NuAndroids
Problem
The event needed dynamic, client-editable content with real-time publishing across devices.
Solution
An event website integrated with Sanity CMS for dynamic content, blog posts, and media — with seamless client-side editing and real-time publishing.
- Sanity CMS integration for dynamic event content, blog posts, and media.
- Seamless client-side editing with real-time publishing.
- Maintained performance and responsiveness across devices.
A real-time IoT pipeline on AWS.
Device data flows from mobile clients through NestJS microservices and Redis into AWS IoT Core — streaming live to and from connected devices. This is the backbone of the IoT systems I build at Nepal Digital Systems.
Mobile
Client devices
API Gateway
Entry / auth
NestJS
Microservices
Redis
Cache / pub-sub
AWS IoT Core
Message broker
Devices
Telemetry
WebSocket
Real-time streaming
MongoDB
High-throughput storage
Docker
Containerized services
ECS / Fargate
Auto-scaling compute
The stack behind the systems.
Grouped by discipline — from cloud infrastructure to the data and services that run on it.
What I bring to production.
Not vanity metrics — the concrete engineering capabilities behind the systems I ship.
Production Engineering
Shipping cloud applications, APIs, and distributed systems.
IoT Data Ingestion
Device-to-cloud pipelines on AWS IoT Core with WebSocket streaming.
Background Workers
BullMQ + Redis job processing that keeps APIs responsive under load.
Containerized Microservices
NestJS services on Amazon ECS & Fargate.
AWS Deployments
Lambda, AppSync, DynamoDB, and Amplify across multiple products.
Automated Pipelines
AWS Amplify CLI and GitHub Actions for reliable delivery.
A look at the craft.
Representative snippets across the stack — queue workers, real-time gateways, GraphQL schemas, and serverless handlers.
@Processor('emails')
export class EmailProcessor extends WorkerHost {
constructor(private readonly mailer: MailerService) {
super();
}
async process(job: Job<EmailJob>): Promise<void> {
const { to, template, payload } = job.data;
await this.mailer.send({ to, template, payload });
await job.updateProgress(100);
}
}Contact
Let's build something reliable.
Have a backend, cloud, or distributed systems challenge? I'm open to engineering roles and collaborations. Let's talk.