DEV Community: Farhan Shahriar

⚡ Boosting API Performance: 5 Practical Techniques Every Developer Should Know

Farhan Shahriar — Thu, 07 Aug 2025 17:37:03 +0000

When it comes to building scalable, high-performance APIs, the devil is in the details. We often focus on functionality and endpoints—but performance? That’s what keeps users happy and systems healthy.

In this article, we’ll walk through five essential techniques to optimize your API for speed, efficiency, and a better user experience. These aren't theoretical ideas—each method is practical, proven, and ready to implement in real-world scenarios.

Let’s dive in. ⚙️

📊 1. Pagination: Serve Data in Bite-Sized Chunks

Large datasets can overwhelm both your server and your users. That’s where pagination comes in.

Instead of dumping thousands of records in one go, pagination breaks that data into manageable pages—like splitting a massive novel into chapters.

Why it matters:

Reduces memory usage on the server
Improves response time for the client
Keeps interfaces snappy and interactive
Helps maintain stability under heavy load

📌 Perfect for product listings, user feeds, search results, etc.

📝 2. Synchronous Logging: Smarter Logging, Fewer Delays

Every log write is an I/O operation—and doing it after every event can slow things down a lot.

Synchronous logging changes the game by batching logs in memory before writing them to disk. It’s like saving up your receipts and filing them all at once.

Why it matters:

Reduces disk write frequency
Minimizes I/O delays
Frees up CPU for real-time request handling
Ensures logs are still safely persisted

🧠 A great balance between performance and reliability.

⚡ 3. Caching: Stop Repeating Yourself (and Your Database)

Why hit your database for the same data over and over?

With tools like Redis, you can cache frequently requested data in-memory—returning lightning-fast responses without touching your backend DB.

Why it matters:

Massive drop in DB read operations
Significantly lower latency
Higher throughput for read-heavy workloads
Scales effortlessly for high-traffic apps

🎯 Ideal for user profiles, product data, config settings, etc.

📦 4. Payload Compression: Shrink Your Data, Speed Up Delivery

APIs often serve large JSON or XML payloads—but not all clients have fast internet. That’s where gzip compression shines.

By compressing your API responses, you reduce data size and improve transfer speed—especially noticeable on mobile or slow connections.

Why it matters:

Reduces bandwidth usage
Speeds up uploads and downloads
Enhances performance for end users
Especially helpful with verbose APIs

🛠️ Enable gzip in your web server or backend framework config.

🔄 5. Connection Pooling: Keep Your DB Connections Warm

Opening a new database connection per request? That’s like calling the restaurant every time you want another bite.

Connection pooling maintains a pool of reusable connections—eliminating the cost of open/close cycles.

Why it matters:

Reduces latency for DB queries
Prevents bottlenecks under high concurrency
Saves server resources
Boosts overall performance

🔥 Most ORMs and frameworks support pooling—just configure it properly.

🚀 Stack These Techniques for Maximum API Performance

Each technique offers a boost—but together? That’s where real performance lives:

✅ Pagination, caching, and compression reduce data and network load

✅ Logging and connection pooling optimize resource use

✅ Combined, they create scalable, reliable, and fast APIs

These aren’t “nice-to-haves.” They’re essentials in any modern developer’s performance toolkit.

Have you used any of these techniques? What’s made the biggest difference in your APIs?

💬 Drop your experiences or questions in the comments below!

Introduction to Backend Development-Part 1

Farhan Shahriar — Fri, 18 Jul 2025 15:34:21 +0000

Before diving into backend development, it’s essential to understand where to start—and more importantly, how far to go. The “end” isn’t clearly defined. Your goal should be reaching a level where you’re comfortable continuing learning independently.

Backend Developer Responsibilities
Roles vary significantly depending on company size:

Startup / Solo Product: You build the entire stack—frontend, backend, database, API, architecture, cloud, security, and documentation.

Small team (5–6 people): You still handle many responsibilities, though some tasks are shared.

Established startup: You likely specialize in backend or system design without cloud or infra work.

Enterprise: Roles become highly specialized—e.g., API design, test coding, documentation or architecture.

Learning Roadmap Overview
The following progression targets foundational backend skills suitable for most early-career developers:

1. API Design
Design how data flows between client and server:

REST API – Dominant pattern, easy to get started

GraphQL – Flexible queries and reduced over-fetching

gRPC – High-performance communication (usually microservices)

SOAP – Mostly obsolete; only relevant if you're working with legacy systems

Real-time communication via WebSockets, though resource-intensive to scale. Avoid message brokers (RabbitMQ, Kafka) at the beginner stage.

2. API Security
Fundamental authentication/authorization elements:

JWT Token – JSON Web Tokens for stateless auth

Refresh Token – Used for secure long-lived sessions

OAuth2 – Allows login via third-party identities (Gmail, Facebook, GitHub)

Advanced topics like SAML, Auth0, Firebase Auth, or Cognito are optional at this stage.
Focus next on Role‑Based Authorization: controlling access by user role (e.g. admin vs. moderator vs. member).

3. API Testing & Documentation
Ensure your API works—and stays documented:

Unit Testing – Test individual components

Acceptance Testing / Integration Tests – Test end-to-end behavior

Load Testing – Ensure performance under strain

For documentation:

Swagger – Automatically generate API docs

Postman – Ideal for building, documenting and sharing API specs

4. Databases & Caching
Basic usage, not admin-level mastery:

Databases

NoSQL: MongoDB, AWS DynamoDB

SQL: PostgreSQL, MySQL, MSSQL, Oracle

In-Memory Storage / Caching

Redis (multi-use, highly recommended)

Memcached (caching-only use case)

Graph databases (e.g. Neo4j) are powerful, but only needed for advanced ML/graph-based use cases—not essential for beginners.

Designing Systems by Requirement
Learning concept names is easy—but interpreting business requirements to select the right architecture is the hardest skill. You'll need to analyze non-technical requirements and map them to technical choices, such as choosing REST vs. GraphQL or deciding when to cache with Redis.

Server & API Implementation Workflow
Fundamentally, your server must:

Listen for incoming requests

Process the request—including accessing business logic, data structures, algorithms, or database

Respond to the client

Example: Raw Node.js HTTP Server (server.js)

`const http = require('http');

const server = http.createServer((req, res) => {
  if (req.url === '/') {
    res.statusCode = 200;
    res.end('<h1>Hello World</h1>');
  } else if (req.url === '/hello') {
    res.statusCode = 200;
    res.end('<h1>Hello Guest</h1>');
  } else {
    res.statusCode = 404;
    res.end('<h1>404 Not Found</h1>');
  }
});

server.listen(8000, () => {
  console.log('Server is listening on port 8000');
});`

This implements the request-listen → process → response flow manually—useful to understand how frameworks simplify this pattern.

Example: Express.js Server
Using Express removes boilerplate and adds routing, middleware, and JSON parsing:

const express = require('express');
const app = express();

app.use(express.json());

const books = [
  // array of { id, name, price }
];

app.get('/books', (req, res) => {
  const { show, price } = req.query;
  if (show === 'all') return res.json(books);

  if (price === '500') return res.json(books.filter(b => b.price <= 500));
  if (price === '1000') return res.json(books.filter(b => b.price <= 1000));

  return res.json(books);
});

app.post('/books', (req, res) => {
  books.push(req.body);
  res.json(books);
});

app.listen(8000, () => {
  console.log('Server is listening on port 8000');
});

Sample routes:

/books – list all books

/books?show=all

/books?price=500 or price=1000

Adding new books via POST /books

Backend Request Lifecycle Pipeline
A modern backend typically follows this flow:

Incoming Request
↓
Middleware: logger, body parser, file parser, auth, validation
↓
Controller: business logic
↓
Middleware: error handler
↓
Response to client

Learning Path Summary

Learn API design (REST + GraphQL/gRPC concepts)

Master API security (JWT, refresh tokens, role-based access)

Set up testing and documentation (unit tests, Postman, Swagger)

Choose and query databases; implement caching (Redis)

Build projects from scratch in Node.js / Express to understand underlying processes

Evolve toward system design skills: analyzing requirements and choosing the right architecture

Conclusion
Although backend touches many concepts—databases, security, APIs, infrastructure—the central challenge is system design based on requirements. Everything else—frameworks, caching tools, database engines—becomes easier once you master understanding and mapping business needs.

Build simple projects: start with raw Node.js, upgrade to Express with CRUD APIs, layer in tests and documentation, then explore security and caching. From there, real-world requirements will shape your deeper learning path.

🏗️ Designing a Project File Structure: Practical Guide Inspired by Clean Code Architecture

Farhan Shahriar — Fri, 11 Jul 2025 18:15:42 +0000

Designing a good file structure for your project is one of the trickiest yet most critical tasks. A well-thought-out structure keeps your project maintainable and helps you avoid constant refactoring headaches as the application grows.

There’s a design principle that guides us here, known as Clean Code Architecture. Though this is an advanced concept that we'll explore in detail later, it offers powerful insights into how and why to organize your code.

Right now, we’re building a Monolithic application. This means everything lives in a single deployable unit, rather than splitting into microservices. Monolithic architecture is often structured following what’s formally called Layered Architecture, but most developers simply know it as monolithic.

Let’s walk through the practical steps to structure your project so it stays clean, understandable, and scalable—even before fully adopting Clean Architecture.

🗂 Recommended Project Folders & Why They Matter

Here’s a practical breakdown of folders and files you should create, along with why each exists:

app/
Holds core application logic like custom errors, database connection code, the main app file, and global routes.
Note: This folder is separate from your server.js file.

routes/
Contains all your route definitions. Helps keep your HTTP layer organized and modular.

models/
Where you define data models (e.g., using Mongoose, Sequelize, etc.) that map to your database.

controller/
Each route typically has an associated controller function. This folder stores all controllers to keep your business logic separate from route definitions.

service/
We never want controllers to talk directly to the database. Instead, services handle database interactions or external API calls.
This cleanly separates business logic from database logic, making your code easier to test and change.

middleware/
Custom middleware functions live here. Examples: authentication checks, logging middleware, request validation, etc.

util/
Utility functions or helper scripts that don’t fit elsewhere.

db/
Contains scripts or configurations related specifically to database setup or migrations.

config/
Holds configuration files—for example, environment-specific settings, third-party service configs, etc.

log/
Store application logs here (especially if you use tools like Winston or Morgan).

error/
All your custom error classes or handlers live here, making error management consistent.

test/
Write your automated tests here—unit, integration, or end-to-end.

server.js
Your application's entry point. Sets up and starts the HTTP server.

.env & default.env
Store secrets, API keys, and environment-specific variables that should never be committed to source control.

Inside the app/ folder, you’ll often create an app.js file which sets up the Express app instance, applies middleware, and mounts your routes.
✅ Why this structure helps
Keeps concerns separated (routing, business logic, database logic, configs, etc.)

Makes it easy for new developers to find what they’re looking for.

Encourages writing testable, maintainable code.

Supports gradual migration to clean architecture principles (like Use Cases and Domain layers) if your project grows.

🧪 Going further: When you're ready for Clean Architecture
Clean Architecture takes these principles to the next level:

Defines domain, application, infrastructure, and presentation layers.

Enforces dependency inversion so core business logic doesn’t depend on frameworks or databases.

Makes your system highly testable and flexible.

But don't rush—start simple, then refactor gradually as complexity grows.

✍️ Final Thoughts
A clear, intentional file structure isn’t just about neat folders—it’s a foundation for scaling your project, onboarding team members, and keeping bugs away.

By following this practical approach inspired by clean architecture, you’ll save countless hours and future-proof your codebase—even if you’re building a monolithic application today.

🖥️ How Code Runs: A Beginner’s Guide to What Happens When You Press “Run”

Farhan Shahriar — Sat, 05 Jul 2025 11:09:51 +0000

When I first started learning to code, I wondered: How does my computer know what to do when I write some text and click “Run”?

In this first lesson, I’ll share what I learned — and trust me, understanding this makes you appreciate programming so much more!

📹 Let’s Compare It To Something You Know

Imagine you want to watch a video on your computer. You need video player software — like VLC or Windows Media Player.Or, you want to play a game — you first install the game on your machine.

Running code is very similar.

When you write code, your computer needs a special program that knows how to understand and execute it.For example:

To run C++, you need a compiler like GCC.

To run Java, you need the Java Development Kit (JDK) installed.

If you run your code online, you use an online IDE (like Replit or CodeSandbox). Your code runs on another computer (a server) somewhere in the world. Still, it always needs a machine to run.

✅ What Happens When You Run Code?

Let’s take a simple C++ example:

#include <iostream>
using namespace std;

int main() {
  // Your code goes here
  cout << "Hi...";
  return 0;
}

When you hit Run, your computer does this in two main steps:

1️⃣ Compilation Phase

It checks your code line by line.

It finds any errors — like typos or wrong syntax.

2️⃣ Execution Phase

It looks for the entry point — in C++ that’s int main().

Then, it starts running your instructions step by step.

Here’s a quick Java example too:

import java.util.*;
import java.lang.*;
import java.io.*;

class FirstCode {
  public static void main(String[] args) throws java.lang.Exception {
    // Your code goes here
  }
}

Again, Java finds the main method and starts executing your logic from there.

🤯 So Much Happens Behind the Scenes!

Behind that Run button, there are thousands of lines of code written by other developers — the compiler, the interpreter, the virtual machine. All of this software does the hard work of translating your code into instructions your computer can understand.

If it wasn’t for these tools, we’d have to write those low-level instructions ourselves. Thankfully, people already did that work and packaged it for us!

🗂️ Does Every Language Run the Same Way?

Most programming languages follow a similar flow:

Check for errors

Find the starting point

Execute the code step by step

The exact details depend on the language (some are compiled, some are interpreted, some use virtual machines). But the big idea stays the same:👉 You write instructions → A special program understands them → Your computer does the work

🚀 Key Takeaway

Whenever you write code, you’re actually giving instructions to a machine. The compiler or interpreter is your translator — it converts your words into something the computer’s hardware understands.

So next time you click Run, appreciate the invisible magic happening behind your screen!

📌 Final Thoughts

Understanding how code runs is the first step to becoming a confident programmer.I hope this helped you — follow my journey as I share more beginner-friendly lessons!