Open to backend engineering roles

Designing Backend Systems. Scaling Reliable APIs

Backend engineer focused on building secure, scalable, and production-ready services. I work close to APIs, data, and system boundaries — designing authentication flows, background processing, and data models that hold up under real-world usage.

Express.js · Node.js · TypeScript · MongoDB · REST APIs · BullMQ · JWT

Download resume

Find me on:

javascript

Express Server

1

import express from 'express';

2

import { User } from './models/User.js';

3

4

const app = express();

5

const PORT = process.env.PORT || 5000;

6

7

app.use(express.json());

8

9

app.post('/api/users', async (req, res) => {

10

const result = await User.create(req.body);

11

res.json({

12

success: true, data: result

13

});

14

});

15

16

app.listen(PORT, () =>

17

console.log('Server running on port:', PORT)

18

);

Competencies

Backend Capabilities

My backend skillset is centered around system design, data integrity, and reliable service execution.

API & Security

Node.jsExpress.jsTypeScriptREST APIsJWTRBACZodbcryptBottleneck

Data & Async Processing

MongoDBMongoosePostgreSQLVectorDBIndexesBullMQQueuesWorkers

Tools & DevOps

GitGitHubPostmanVS CodeVercelDockerDNS Setup

What I Handle at the Backend Layer

API & Service Design

Designing RESTful APIs with clear contracts and predictable behavior
Input validation using Zod at system boundaries
Structured error handling and consistent response formats
API versioning and backward-compatible changes

Authentication & Security

JWT-based authentication with access & refresh token strategies
Implementing role-based access control (RBAC)
Secure sensitive data by hashing
Protecting sensitive routes with middleware - level authorization

Data & Persistence

Schema design and data modeling using MongoDB and PostgreSQL
Indexing strategies for query performance
Handling relational and document-based data trade-offs
Designing data access layers with clear separation of concerns

Asynchronous & Background Processing

Background job processing using BullMQ.
Decoupling long-running tasks from request lifecycles
Retry strategies and Fault Tolerance
Designing event-driven flows for better scalability

Featured Work

Projects That Stand Out

AI-Powered Recruiting & Job Searching

AI-Powered job recruting, job ranking, and job searching platforlm. Architected a high-concurrency backend system using Node.js and TypeScript to automate recruitment workflows through AI-driven intelligence. The platform features a distributed processing engine that performs deep-dive Skills Gap Analysis between candidate resumes and job descriptions to generate structured, context-aware interview guides.

Backend Responsibilities

Designed RESTful APIs for job ingestion, filtering, and retrieval
Implemented JWT-based authentication with role-based access control
Centralized validation and error handling at API boundaries
Implemented a Global Rate Limiter using Bottleneck and Redis to manage external AI API quotas across multiple workers.
Integrated Zod schemas with LLM outputs to ensure strictly typed JSON responses
Implemented Distributed background Job Processing by configuring BullMQ with custom backoff strategies and lock durations for long-running AI tasks.

Expres.jsTypeScriptMongooseMongoDBJWTZodRedisLLM APIsBullMQBottleneck Source Live Demo

AI powered job recruiting system with background job. — Figure: A high level workflow diagram of embedding when a new job is posted in our AI-powered recruiting platform.

Travel Tips & Destination Guides

A modular backend system for a travel platform supporting user-generated content, premium features, and secure payment workflows. Designed with clear service boundaries, role-based access control, and transactional updates to ensure consistent user state after payment verification.

Backend Responsibilities

Implemented JWT-based authentication & RBAC for protected user
Designed structured RESTful APIs for travel content and user interactions
Integrated payment gateway verification before upgrading user premium access
Ensured Transaction Reliability using rollback strategies for critical payment processing flows
Integrated Supporting Services including Nodemailer and Cloudinary for media and notifications

Express.jsTypeScriptMongooseJWTZodNodemailerCloudinaryPayment GatewayMongoDB Transactions Source Live Demo

Fore more projects, please visit my GitHub account

Backend Decision & Trade-off

Backend Principles & Engineering Practices

I treat backend systems as long-lived assets. My focus is on correctness, Reliability, Maintainability, predictability, and safe failure under real-world conditions. These are the backend trade-off and engineering practices I follow to ensure systems perform well.

Asynchronous Processing vs Synchronous APIs

For long-running or unpredictable tasks, I avoid blocking request lifecycles. Instead, I decouple execution using background job queues.

✔ Improves API response time
✔ Increases fault tolerance
✔ Enables retry and failure isolation
✖ Adds operational complexity and queue monitoring

Asynchronous and Synchronous diagram — Figure: Asynchronous and Synchronous APIs flow example.

Schema Design & Validation at System Boundaries

I enforce strict input validation at API boundaries to prevent invalid data from entering the system.

✔ Protects data integrity at the database layer
✔ Simplifies downstream business logic
✔ Produces predictable and debuggable failures
✖ Requires upfront schema definition and maintenance

Figure: Example of input data validation in server and shows request response and error flows.

Engineering Practices I Follow

✔ Structured request/response logs for traceability
✔ Enforcing strict input validation at API boundaries
✔ Centralized error handling with consistent error shapes and meaningful status codes
✔ Use of environment variables for config isolation
✔ Structuring logs and errors to make production issues easier to diagnose

Performance, Reliability and Quality

✔ Modular service layers separating API, logic, and data access
✔ Rate limiting to protect services under load
✔ Efficient indexing strategies for fast data access
✔ Optimistic retries and timeout configurations
✔ Implementing Caching strategies for frequent data access

About Me

Hi, I’m Masud Rana, a Computer Science student with 2+ years of hands-on backend engineering experience, focused on building reliable, secure, and scalable backend systems.

My academic journey in Computer Science built a strong foundation in data structures, algorithms, DBMS, OOPs, Software Engineering, operating systems, and computer networks. These fundamentals directly shape how I approach backend engineering — reasoning about data flow, performance, consistency, and system boundaries instead of just writing code.

I approach backend development with a systems mindset—prioritizing clear API contracts, data integrity, authentication & authorization, and fault-tolerant design. I enjoy working close to business logic and databases, designing services that are predictable, maintainable, and safe to operate in production.

Dhaka, Bangladesh

CSE Student

6+

Projects Built

2+

Years Hands-on Experience

1+

Publications