DEV Community: Mahdi SHamlou | مهدی شاملو

How to Benchmark Web Frameworks in a Fair, Isolated Way | Mahdi Shamlou

Mahdi SHamlou | مهدی شاملو — Sat, 21 Feb 2026 20:39:44 +0000

Hey everyone! Mahdi Shamlou here 👋

I’ve seen many posts online comparing web frameworks, but most of them are either biased, outdated, or hard to reproduce.

So I wanted to share a practical way to benchmark any web framework, keeping everything isolated, fair, and reproducible.

We’ll use Docker for isolation, k6 for load testing, and Python frameworks — FastAPI and Flask — as simple examples. But the approach works for Node.js, Go, Java, Rust, or anything else.

Why Isolated Benchmarking Matters

Benchmarking web frameworks can be tricky. Many factors affect results:

CPU & memory availability
Number of workers / threads
Background processes
Routing, logging, database, I/O

To make a fair comparison, you need:

Docker containers with fixed CPU & memory
Identical routes or endpoints in each framework
Controlled load tests using k6 or similar tools
Results saved for later analysis

Step 1 — Project Structure

mkdir web_framework_benchmarks
cd web_framework_benchmarks
mkdir framework1 framework2 k6-tests results

You can replace framework1 and framework2 with any frameworks you want to compare.

Step 2 — Sample API Route

For demonstration, we use a simple /hello endpoint.

Python Example (FastAPI):

from fastapi import FastAPI
app = FastAPI()

@app.get("/hello")
def hello():
    return {"message": "hello world"}

Python Example (Flask):

from flask import Flask, jsonify
app = Flask(__name__)

@app.route("/hello")
def hello():
    return jsonify({"message": "hello world"})

You can do the same in Node.js, Go, or Java, just keep the endpoint functionally identical.

Optional: add a sleep route to simulate I/O/concurrent load.

Step 3 — Dockerize Your Frameworks

Here’s a funny story:

At first, I ran FastAPI with just uvicorn… and I thought “Yeah, this will do.” But then I realized 🤦‍♂️

If I run Flask with Gunicorn and FastAPI with Uvicorn alone, it’s like comparing a Ferrari to a bicycle… not fair! just fun!

So I fixed it: FastAPI + Gunicorn + UvicornWorker and 1 worker, exactly like Flask.

FastAPI Dockerfile (Fair Version):

FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install fastapi uvicorn gunicorn
CMD ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "-w", "1", "-b", "0.0.0.0:8000", "app:app"]

Flask Dockerfile:

FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install flask gunicorn
CMD ["gunicorn", "-w", "1", "-b", "0.0.0.0:8000", "app:app"]

✅ Now both containers have the same worker count, same CPU/memory limits — fair and square!

Step 4 — k6 Load Testing

k6 scripts for each framework:

import http from "k6/http";
import { sleep } from "k6";

export const options = {
  stages: [
    { duration: "30s", target: 50 },   // ramp-up
    { duration: "1m", target: 200 },   // hold load
    { duration: "30s", target: 0 },    // ramp-down
  ],
  thresholds: {
    "http_req_duration": ["p(95)<200"], // 95% of requests should be <200ms
  },
};

export default function () {
  http.get("http://localhost:8001/hello");
  sleep(1);
}

Run and save results:

mkdir -p results
k6 run --out json=results/framework1.json k6-tests/framework1.js
k6 run --out json=results/framework2.json k6-tests/framework2.js

Works for any language/framework, not just Python.

Step 5 — Analyze Metrics

With Python + matplotlib (or any plotting tool):

Average latency
P95 latency
Requests/sec
Failure rate

import json, numpy as np, matplotlib.pyplot as plt

files = {"Framework1": "results/framework1.json", "Framework2": "results/framework2.json"}
summary = {}

for name, file in files.items():
    durations, fails, total = [], 0, 0
    with open(file) as f:
        for line in f:
            obj = json.loads(line)
            if obj.get("type")=="Point":
                if obj.get("metric")=="http_req_duration": durations.append(obj["data"]["value"])
                if obj.get("metric")=="http_req_failed": fails+=obj["data"]["value"]; total+=1
    if durations:
        summary[name] = {"avg": np.mean(durations), "p95": np.percentile(durations,95), "requests": len(durations), "fail_rate": fails/total if total else 0}

print(summary)
plt.bar(summary.keys(), [summary[n]["avg"] for n in summary])
plt.title("Average Response Time (ms)")
plt.show()

✅ Key Lessons

Docker isolation → makes everything reproducible
Worker count & CPU limits → must match
Simple routes may make Flask look faster, don’t be fooled
Async/I/O-heavy routes → FastAPI (or other async frameworks) shine
Always benchmark your actual workload, not just tiny examples

🔹TL;DR

Pick frameworks → Dockerize with identical resources
Create identical endpoints → optionally simulate I/O
Load test with k6 → save JSON results
Plot metrics → avg latency, P95, requests, fail rate
Compare fairly → draw conclusions based on your workload

📂 Try It Yourself

You can check out my repo: web_framework_benchmarks
Clone it, run the Docker + k6 setup yourself
Explore FastAPI & Flask examples
Or even contribute and add more frameworks for comparison

Want More?

If you enjoyed this deep dive, you might like my other article:

How I Won an Algorithm Competition at University — With a Smart Trick | Mahdi Shamlou

In that post, I share a clever approach that helped me solve tricky algorithm problems efficiently — a real-life example of strategy + code. 🚀

🔗 LinkedIn:
https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram:
https://telegram.me/mahdi0shamlou

📸 Instagram:
https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

Go Web Frameworks Comparison 2026 — Top 5 Picks: Gin, Fiber, Echo, Chi & Beego | Mahdi Shamlou

Mahdi SHamlou | مهدی شاملو — Fri, 20 Feb 2026 08:19:49 +0000

Hey everyone! Mahdi Shamlou here again 👋

After my article on durable workflow engines in Python, I wanted to explore something new: modern Go web frameworks.

I searched online and honestly… most articles were old, incomplete, or clearly biased to one framework

So I decided to write a fresh, practical comparison for 2026 with real benchmark sources and real developer experience.

Let’s go 👇

Why Go for Web Development?

Go became super popular for backend APIs because it gives you:

Very high performance (compiled language)
Easy concurrency with goroutines
Simple deployment (single binary)
Great for microservices and cloud apps

Big companies like Google, Uber, Twitch, Dropbox use Go heavily for backend services.

Top 5 Go Web Frameworks in 2026

1. Gin — The Safe Default Choice

Website → https://gin-gonic.com/
GitHub → https://github.com/gin-gonic/gin

Gin is probably the most used Go framework today. If you don’t know what to pick, pick Gin.

Learning speed: 1–2 days
Benchmark idea: ~50k–70k req/sec

Strengths 👍
• Very easy to start
• Huge community and middleware
• Stable and production‑proven
• Works with standard net/http ecosystem

Trade-offs 👎
• Not opinionated → big projects can become messy
• No built‑in dependency injection
• Some people dislike its context style

2. Fiber — Express.js Style for Go

Website → https://gofiber.io/
GitHub → https://github.com/gofiber/fiber

Fiber feels like Express.js but written in Go. If you come from Node.js, you’ll love it.

Learning speed: 1 day
Benchmark idea: ~70k–110k req/sec

Strengths 👍
• Extremely fast
• Very familiar for Node developers
• Many built‑in features
• Clean and simple syntax

Trade-offs 👎
• Uses fasthttp instead of net/http
• Some Go libraries don’t work
• Debugging can be harder
• Smaller ecosystem than Gin

3. Echo — Clean and Mature Framework

Website → https://echo.labstack.com/
GitHub → https://github.com/labstack/echo

Echo is like the balanced framework. Not too small, not too big.

Learning speed: 2–3 days
Benchmark idea: ~50k–65k req/sec

Strengths 👍
• Clean structure
• Built‑in validation and middleware
• Good documentation
• Mature and stable

Trade-offs 👎
• Smaller ecosystem than Gin
• Some advanced features need extra libraries
• Not as fast as Fiber

4. Chi — Lightweight Router for Clean Architecture

Website → https://go-chi.io/
GitHub → https://github.com/go-chi/chi

Chi is not a full framework. It’s a router used in many serious microservices.

Learning speed: Few hours
Benchmark idea: ~45k–60k req/sec

Strengths 👍
• Very lightweight
• Uses standard net/http
• Perfect for clean architecture
• Easy testing

Trade-offs 👎
• Not beginner friendly
• You must build everything yourself
• No built‑in ORM or helpers
• Slower to start small projects

5. Beego — Full MVC Framework

Website → https://beego.vip/
GitHub → https://github.com/beego/beego

Beego is like Django. It has ORM, CLI, sessions, templates.

Learning speed: 1–2 weeks
Benchmark idea: ~20k–40k req/sec

Strengths 👍
• Everything built‑in
• Fast development for monolith apps
• Good CLI tools
• Built‑in ORM and templates

Trade-offs 👎
• Slower performance
• Heavy compared to Gin or Fiber
• Smaller community today
• Not ideal for microservices

Where These Benchmark Numbers Come From

The numbers above are not random. You can verify them here:

👉 https://www.techempower.com/benchmarks/

This is the most trusted benchmark in backend engineering. It runs frameworks on the same hardware and same workload.

But remember ⚠️
Real performance depends on:
• database usage
• logging
• authentication
• payload size
• TLS
• hardware

So always run your own benchmark.

My Recommendation for 2026

If you are new → Start with Gin.
If you need max performance → Try Fiber.
If you want balanced structure → Use Echo.
If you love clean architecture → Use Chi.
If you want full MVC → Use Beego.

There is no perfect framework. Pick the one that fits your team and project.

Want More?

If you enjoyed this deep dive, you might like my other article:

How I Won an Algorithm Competition at University — With a Smart Trick | Mahdi Shamlou

In that post, I share a clever approach that helped me solve tricky algorithm problems efficiently — a real-life example of strategy + code. 🚀

🔗 LinkedIn:
https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram:
https://telegram.me/mahdi0shamlou

📸 Instagram:
https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Durable Workflow Engines Comparison — Temporal, DBOS Transact, Prefect & Custom Python Engines Mahdi SHamlou

Mahdi SHamlou | مهدی شاملو — Thu, 19 Feb 2026 14:31:10 +0000

Hey everyone! Mahdi Shamlou here again 🚀

After diving into classic algorithm challenges like LeetCode #8 String to Integer (atoi), today I want to explore something a bit different — durable workflow engines in Python.

I noticed most blog posts out there are old, incomplete, or heavily biased toward one tool. So I decided to create a fresh, practical comparison and give my take on which workflow engine you should pick in 2026.

Let’s dive in.

What is a Durable Workflow Engine?

A durable workflow engine helps you run code reliably and safely, even if your app crashes, your machine restarts, or network hiccups occur. They’re particularly useful for:

Long-running processes (hours, days, or even months)
Background jobs and automation
Retry, compensation, and saga patterns
Observability & external signaling

I’ll compare four approaches:

Temporal — the battle-tested distributed platform
DBOS Transact — lightweight embedded durability in Postgres
Prefect 3.x — Pythonic, open-source workflow orchestration
Custom Python engine — pure Python + your own persistence

1. Temporal (temporalio/sdk-python)

Temporal is a production-proven, distributed workflow engine originally built at Uber (as Cadence). It’s used by DoorDash, Snap, Stripe, and others.

How it works:

Workflows as code (functions/classes)
Activities separated from orchestration
External Temporal server handles task durability

Pros:

Maximum durability — even months-long workflows survive anything
Signals, queries, workflow versioning, child workflows
Multi-language support (Python, Go, Java, TS, .NET)
Great observability (Temporal Web UI / Cloud)

Cons:

Requires server/cluster → more ops complexity
Higher learning curve and more code

2. DBOS Transact (dbos-transact-py)

DBOS Transact is an embedded durable engine for Python backed by Postgres. Think of it as “durable Python without leaving your app.”

How it works:

Annotate normal Python functions with @workflow and @step decorators
Each step automatically checkpoints its state in Postgres
On crash/restart, workflow resumes from last checkpoint
External events or signals can be sent with recv() / send() methods
Minimal changes to your existing code — the library handles durability

Pros:

Minimal code changes → easy to adopt
Lightweight, fast, low ops overhead
Great performance for embedded durability

Cons:

Tied to Postgres
Fewer advanced features than Temporal

3. Prefect (Prefect 3.x)

Prefect is a Python-first workflow orchestration framework — great for data pipelines, ML workflows, and automation tasks.

How it works:

Define workflows with @flow and tasks with @task decorators
Each task execution is automatically tracked and persisted (checkpointing)
Flows can be suspended/resumed manually or via events
Result persistence allows retries, caching, and skipping already-completed tasks
Optional Prefect server/agent UI provides real-time observability and control

Pros:

Extremely Pythonic → minimal code friction
Excellent UI and monitoring
Durable execution for long-running flows
Open-source, hybrid execution

Cons:

Durability is checkpoint-based → not full deterministic replay like Temporal
Python-only (no multi-language support)
Some advanced saga patterns require manual handling

4. Pure Python Custom Engine

You could roll your own workflow engine using just Python + a DB or file store.

How it works:

Store workflow instances in a table with workflow ID, current step, status, and data
Poll a queue (e.g., Redis, RQ, Celery) and execute steps based on stored state
Implement retry, timeout, and compensation manually
Signals/events handled with a custom event table or pub/sub system

Pros:

Full control, zero dependencies
Simple for very small workflows

Cons:

Very easy to get wrong — lost state, duplicates, race conditions
No UI or observability out-of-the-box
Maintenance grows with complexity

My Take: Which One Should You Use?

Start with Prefect or DBOS Transact :

Prefect: Best for Python workflows, great UI, caching, event-driven automations. Durable execution with minimal overhead.
DBOS Transact: Ultra-lightweight, embedded durability in Postgres. Great if you want minimal footprint and existing Postgres usage.

Switch to Temporal when you outgrow the lighter options

Need full deterministic replay, months-long workflows, multi-language, or enterprise-scale reliability.

Custom Python engines are mostly for learning, experiments, or extremely simple workflows.

Want More?

If you enjoyed this deep dive into workflow engines, you might like my other article:
Subscribe to the Medium newsletter

How I Won an Algorithm Competition at University — With a Smart Trick | Mahdi Shamlou

In that post, I share a clever approach that helped me solve tricky algorithm problems efficiently — a real-life example of strategy + code. 🚀

🔗 LinkedIn:
https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram:
https://telegram.me/mahdi0shamlou

📸 Instagram:
https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

How I Won an Algorithm Competition at University — With a Smart Trick | Mahdi Shamlou

Mahdi SHamlou | مهدی شاملو — Thu, 19 Feb 2026 12:21:57 +0000

Hi everyone,
Mahdi Shamlou here 🚀

Today I want to share something different from my LeetCode posts.

Recently, I participated in an algorithm & programming competition at Islamic Azad University — and I won! 🎉

The contest had 4 problems, and I want to start with the first one because it taught me an important lesson about thinking before coding.

🧩 Problem 1 — Two Cubes Puzzle

We had to design two cubes with digits on their faces so that we could display every number from 0 to n.

Rules:

Each cube has 6 faces (6 digits).
By placing the cubes side-by-side, we must form all numbers from 0 → n.
If possible → output cube configuration
If impossible → return "Impossible"

Important detail:

We cannot rotate 6 to become 9.
So if we need digit 9, it must exist explicitly on a cube.

💡 My Strategy

At first glance, this looks like a brute-force search problem:

Generate combinations
Test permutations
Check all numbers

But I realized something:

👉 The number of valid configurations is extremely limited.

So instead of writing a complex generator, I solved the cube puzzle manually on paper first.

After finding the correct configuration, I simply returned that fixed solution in code.

No brute force.
No heavy computation.
Just logic.

❗ The Impossible Case

Because we need digit 9 explicitly and cannot reuse 6 as 9:

👉 If n > 30, the answer is "Impossible".

30 is the maximum achievable upper bound with valid cube digit placement.

🐍 Python Implementation

Here is the corrected Python version:

def two_cubes_solution(n):
    # Impossible case
    if n > 30:
        return "Impossible"

    # Pre-calculated cube faces (solved manually)
    cube1 = [1, 2, 3, 4, 5, 6]
    cube2 = [0, 1, 2, 7, 8, 9]

    return cube1, cube2


# Example usage
n = int(input())
print(two_cubes_solution(n))

🚀 Why This Approach Won

✔ O(1) time
✔ O(1) space
✔ Zero computation overhead
✔ Guaranteed correctness

The key lesson:

Sometimes the smartest algorithm is solving the logic once and letting the code stay simple.

I’ll share the next competition problem soon — that one was much more algorithm-heavy 😄

Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Solving LeetCode #8: String to Integer (atoi) — Step by Step

Mahdi SHamlou | مهدی شاملو — Sat, 31 Jan 2026 12:02:11 +0000

Hey everyone! Mahdi Shamlou here — continuing my LeetCode classic problems series 🚀

After [#7 Reverse Integer (See the list that I solved)], today I jumped into Problem #8 — String to Integer (atoi).

At first glance, this one looks easy… but once you start reading the rules carefully, you realize it’s all about edge cases 😅

Problem Statement:

Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer.

The algorithm should:

Ignore leading whitespace
Check for an optional + or - sign
Read digits until a non-digit is found
Clamp the result to the 32-bit signed integer range: [-²³¹, ²³¹ − 1]
Return 0 if no valid conversion exists

Examples:

Input: "42"
Output: 42
----
Input: "   -42"
Output: -42
----
Input: "4193 with words"
Output: 4193
----
Input: "words and 987"
Output: 0

My Thought Process

When I started, I told myself:

Okay… don’t panic. Just follow the rules one by one. just do it !

So I broke the problem into simple steps:

Skip all leading whitespaces
Detect the sign (+ or -)
Read digits and build the number
Handle overflow before it happens

That last part is super important — Python won’t overflow, but LeetCode expects 32-bit behavior.

My Solution (Clean & Safe)

class Solution:
    def myAtoi(self, s: str) -> int:
        """
        first of all i think i can just jump empty section of s

        """
        # Step 1: Skip whitespaces
        i = 0
        n = len(s)
        while i < n and s[i] == ' ':
            i += 1

        if i == n:
            return 0

        # Step 3: find sign
        sign = +1
        if s[i] == '-':
            sign = -1
            i += 1
        elif s[i] == '+':
            i += 1

        # Step 4: read the s for findig ints 
        result = 0
        INT_MAX_OF_OVERFELLOW = 2**31 - 1   # 2147483647
        INT_MIN_OF_OVERFELLOW = -2**31      # -2147483648

        while i < n and s[i].isdigit():
            digit = int(s[i])


            if result > (INT_MAX_OF_OVERFELLOW - digit) // 10:
                return INT_MAX_OF_OVERFELLOW if sign == 1 else INT_MIN_OF_OVERFELLOW

            result = result * 10 + digit
            i += 1


        return result * sign

sorry my comments not okay :)

Why I Like This Approach

️ Easy to read
️ Matches the problem rules exactly
️ Handles all edge cases

Final Thoughts

This problem taught me something important:

Sometimes the “hard” part isn’t the algorithm — it’s discipline.

Reading carefully.
Handling edge cases.
Not rushing.

And yes… after passing all test cases in first time, I had that quick “okay, nice” moment — and then I jumped straight to the next problem 🚀

My Repo (All Solutions)

GitHub — mahdi0shamlou/LeetCode

What about you?

How did you approach this problem?
Did you miss any edge case the first time?

Drop your thoughts — I read everything! 🚀
Connect with me

🔗 LinkedIn:
https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram:
https://telegram.me/mahdi0shamlou

📸 Instagram:
https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Solving LeetCode #7: Reverse Integer — My Math-Based Reversal with Overflow Safety

Mahdi SHamlou | مهدی شاملو — Sat, 31 Jan 2026 11:53:08 +0000

Hey everyone! Mahdi Shamlou here — continuing my LeetCode classic problems series 🚀

After [#6 Zigzag Conversion (See the list that I solved)], today we’re tackling Problem #7 — Reverse Integer — a very common easy/medium question that looks simple at first… until you remember the 32-bit integer overflow trap!

Problem Statement :

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-2³¹,2³¹ — 1], then return 0.

Assume the environment does not allow 64-bit integers.

Examples:

Input: x = 123
Output: 321

Input: x = -123
Output: -321

Input: x = 120
Output: 21

Input: x = 0
Output: 0

My solution:

digit-by-digit reversal with overflow check . I decided to avoid string conversion and do it mathematically — pop digits with % 10, build the reversed number, and most importantly check for overflow before multiplying by 10 and adding the digit.

class Solution:
    def reverse(self, x: int) -> int:

        reversed_x = 0 # create reverse_x to return 

        # Try to Handle the sign separately
        if x >= 0:
            sign = 1
        else:
            sign = -1

        x = abs(x)

        while x > 0:
            digit = x % 10
            x = x // 10

            # checks for overflow before adding the new digit
            # 2**31 - 1 is equals = 2147483647
            # -2**31    is equals = -2147483648

            if reversed_x > (2147483647 - digit) // 10: # but you can use dynamic number calculation like 2**31-1
                return 0
            if reversed_x < (-2147483648 + digit) // 10:
                return 0

            reversed_x = reversed_x * 10 + digit

        return sign * reversed_x

It passes all cases — and feels clean because we catch overflow before it actually happens.

My repo (all solutions are here): GitHub — mahdi0shamlou/LeetCode: Solve LeetCode Problems

Time & Space
Time: O(log |x|) — we process each digit once
Space: O(1) — just a few variables

What about you? Did you also do it mathematically like me? How did you handle the overflow part — did you use constants or 2**31?

Share in the comments — I read everything! 🚀

And honestly… after seeing those overflow cases return 0 correctly and the normal ones reverse perfectly, I just smiled and thought “yes — safe and elegant!” 😂 Here’s me right after submitting:

Connect with me:

🔗 LinkedIn: https://www.linkedin.com/in/mahdi-shamlou

📱 Telegram: https://t.me/mahdi_shamlou

📸 Instagram: https://www.instagram.com/mahdi.shamlou

Author: Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Solving LeetCode #6: Zigzag Conversion — My Row-by-Row Simulation Fun Way

Mahdi SHamlou | مهدی شاملو — Sat, 31 Jan 2026 11:43:25 +0000

Hey everyone! Mahdi Shamlou here — rolling on with my LeetCode classic problems series 🚀

After [#5 Longest Palindromic Substring (See the list that i solved)], today we’re tackling Problem #6 — Zigzag Conversion (also called ZigZag Conversion) — a cool medium-level problem that feels like drawing a zigzag pattern with letters!

Problem Statement

The string s is written in a zigzag pattern on a given number of rows like this (imagine fixed font):

For s = “PAYPALISHIRING”, numRows = 3:

P   A   H   N
A P L S I I G Y
I   R

Read line by line: “PAHNAPLSIIGYIR”

Write a function to convert the string this way given numRows.

Examples:

Input: s = "PAYPALISHIRING", numRows = 3
Output: "PAHNAPLSIIGYIR"

Input: s = "PAYPALISHIRING", numRows = 4
Output: "PINALSIGYAHRPI"
Explanation:
P     I    N
A   L S  I G Y
A   H R
P     I

Input: s = "AB", numRows = 2
Output: "AB"

My solution :

The simulation way with direction flip (this felt natural!) I imagined walking down the rows, then up, then down again — like a real zigzag. So I used a list of strings (one per row), a counter for current row, and a direction flag that flips at top/bottom.

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        result = []
        numRows_counter = 0
        numRows_counter_way = 1

        for i in s:
            result.append("")  # wait, this was a bug — should init outside!
            result[numRows_counter] = str(result[numRows_counter]) + str(i)

            if numRows_counter + 1 == numRows:
                numRows_counter_way = -1
            if numRows_counter - 1 < 0:
                numRows_counter_way = +1

            if numRows_counter_way == 1:
                numRows_counter = numRows_counter + 1
            else:
                numRows_counter = numRows_counter - 1

        final_res = ""
        for i in result:
            final_res = final_res + i

        print(result)
        return final_res

Note: In my first run I had result = [] and appended empty string each time — that’s not correct! (It would create too many empty slots.) The proper way is to initialize result = [“”] * numRows outside the loop. But hey, this direction-flip idea still clicked for me after fixing that 😅

My repo (all solutions are here):

GitHub — mahdi0shamlou/LeetCode: Solve LeetCode Problems

What about you? Did you simulate the zigzag with rows like me, or did you go for the math formula way (cycle length = 2*numRows-2)? Any funny bugs you hit on this one?

Share in the comments — I read everything! 🚀

And honestly… after seeing “PINALSIGYAHRPI” come out correctly I just sat there grinning like an idiot — that zigzag finally made sense in code! 😂 Here’s me right after it worked:

Connect with me:

🔗 LinkedIn: https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram: https://telegram.me/mahdi0shamlou

📸 Instagram: https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Solving LeetCode #5: Longest Palindromic Substring — My Expand-Around-Center Adventure

Mahdi SHamlou | مهدی شاملو — Sat, 31 Jan 2026 11:33:16 +0000

Hey everyone! Mahdi Shamlou here — keeping the LeetCode classic problems series rolling 🚀

After [#4 Median of Two Sorted Arrays], today we’re diving into Problem #5 — Longest Palindromic Substring — another super famous one that shows up in tons of interviews!

Problem Statement Given a string s, return the longest palindromic substring in s.

A palindrome reads the same forwards and backwards.

Examples:

Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer (both length 3)

Input: s = "cbbd"
Output: "bb"

Input: s = "a"
Output: "a"

My solution — the expand-around-center way (this clicked for me!) When I first thought about it, checking every possible substring sounded painful (O(n³) nightmare 😅). Then I imagined and then I realized: palindromes can expand from the center!
Become a member

So I wrote this version — check around each character (for odd-length palindromes) and between each pair (for even-length):

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s:
            return ""

        start = 0
        end = 0

        def expand_around_center_v2(left: int, right: int):
            while left >= 0 and right < len(s) and s[left] == s[right]:
                left -= 1
                right += 1
            return left + 1, right - 1

        for i in range(len(s)):
            # Case 1: Odd length palindrome (center is single char)
            # Example: "aba" → center at 'b'
            l1, r1 = expand_around_center_v2(i, i)

            # Case 2: Even length palindrome (center between two chars)
            # Example: "bb" → center between the two 'b's
            l2, r2 = expand_around_center_v2(i, i + 1)

            if r1 - l1 > end - start:
                start, end = l1, r1

            if r2 - l2 > end - start:
                start, end = l2, r2

            print(f"start : {start} and end : {end}")   # I kept these to watch it grow 😂
            print("#" * 100)

        return s[start:end + 1]

Time Complexity: O(n²)
Space Complexity: O(1) → Perfect!

It feels so elegant — we expand outward as long as characters match, and we do it for every possible center. Time complexity is O(n²) because each expansion can take up to O(n), and we have ~2n centers — but in practice it runs really fast! And also no need to generate all possible substrings (which would be O(n³))

My repo (all solutions are here):

GitHub — mahdi0shamlou/LeetCode: Solve LeetCode Problems

What about you? Did the expand-around-center idea click for you right away, or did you start with something crazier like checking every substring? 😅 Any favorite test cases that break naive solutions?

Share in the comments — I read everything! 🚀

And honestly… after seeing “bb” pop out correctly and watching those print statements show the window growing, I just leaned back, laughed, and thought “yes — this actually works and looks clean!” 😂 Here’s me right after submitting and passing:

Connect with me:

🔗 LinkedIn: https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram: https://telegram.me/mahdi0shamlou

📸 Instagram: https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Solving LeetCode #4: Median of Two Sorted Arrays — My First Attempt

Mahdi SHamlou | مهدی شاملو — Fri, 23 Jan 2026 17:11:09 +0000

Hey everyone! Mahdi Shamlou here — continuing my LeetCode classic problems series.

After [Longest Substring Without Repeating Characters], today we’re looking at Problem #4 — Median of Two Sorted Arrays — one of the famous hard ones!

Problem Statement

Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.

Examples:

Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.0
-----
Input: nums1 = [1,2], nums2 = [3,4]
Output: 2.50000
Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5
-----
Input: nums1 = [], nums2 = [2,3]
Output: 2.50000

My first intuitive solution (the fun & lazy way I tried) This is exactly what came to my mind when I first saw it — just throw everything together:

class Solution:
    def findMedianSortedArrays(self, nums1, nums2):
        list3 = nums1 + nums2           # just combine them
        list3 = sorted(list3)           # sort everything
        mid = len(list3) / 2

        print(list3)                    # I even printed to see what happens 😂
        print(f'mid is {mid}')

        if len(list3) % 2 == 0:         # even number of elements
            return (list3[int(mid)] + list3[int(mid)-1]) / 2
        else:                           # odd
            return list3[int(mid)]

It works, it’s super readable, and honestly — for small inputs — it feels very satisfying to write 😄

My repo (all solutions are here): GitHub — mahdi0shamlou/LeetCode: Solve LeetCode Problems

What about you? How did you first approach this problem? Did you also just merge + sort at the beginning like me? 😅 Or did you go straight to something else?

And honestly… after finally getting this naive version to pass all test cases, I just sat back, laughed at how simple (yet not-so-efficient) it was, and felt that sweet mix of relief and “I did it!” energy 😂 Here’s me right after hitting “Submit”:

Share in the comments — I read everything! 🚀

Connect with me:

🔗 LinkedIn: https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram: https://telegram.me/mahdi0shamlou

📸 Instagram: https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Solving LeetCode #3: Longest Substring Without Repeating Characters — My First Attempt & My Optimal Way

Mahdi SHamlou | مهدی شاملو — Fri, 23 Jan 2026 17:01:36 +0000

Hey everyone! Mahdi Shamlou here — continuing my LeetCode classic problems series.

After [Add Two Numbers], today we’re solving Problem #3 — Longest Substring Without Repeating Characters — another very famous interview question!

Problem Statement

Given a string s, find the length of the longest substring without repeating characters.

Examples:

Input: s = "abcabcbb"
Output: 3
Explanation: "abc" is the longest substring without repeating characters.

Input: s = "bbbbb"
Output: 1

Input: s = "pwwkew"
Output: 3
Explanation: "wke" (length 3)

My first intuitive solution (Brute Force style)

This was my very first idea when I solved it:

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        max_len = 0
        lists = []
        for i in range(0, len(s)):
            for z in range(i, len(s)):
                if s[z] in lists:
                    lists = []
                    break
                else:
                    lists.append(s[z])
                if max_len < len(lists):
                    max_len = len(lists)
        return max_len

What’s wrong with this solution?

Time complexity ≈ O(n³) → very slow for longer strings
Using in on list is O(n) → big performance killer

My Optimal Way — Sliding Window (O(n) time)

This is the approach almost everyone expects in interviews today:

class Solution:
    def lengthOfLongestSubstring(self, s):
        my_last_seen_char_in_s = {}
        left_of_window = 0
        max_len = 0

        for right_of_window, char in enumerate(s):
            if char in my_last_seen_char_in_s and my_last_seen_char_in_s[char] >= left_of_window:
                left_of_window = my_last_seen_char_in_s[char] + 1

            my_last_seen_char_in_s[char] = right_of_window
            max_len = max(max_len, right_of_window - left_of_window + 1)

        return max_len

Why this is beautiful:

1.Single pass → O(n) time
2.Uses dictionary for instant lookup
3.Smartly jumps the window when duplicate is found
4.Very clean and easy to explain

My repo (all solutions are here)

What about you? Which approach do you like most? Do you have any other creative solutions? Share in the comments — I read everything! 🚀

Connect with me:

🔗 LinkedIn: https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram: https://telegram.me/mahdi0shamlou

📸 Instagram: https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Solving LeetCode #2: Add Two Numbers — The Classic Linked List Addition

Mahdi SHamlou | مهدی شاملو — Fri, 23 Jan 2026 16:51:55 +0000

Hey everyone! I’m Mahdi Shamlou, and I’m continuing my new series on classic LeetCode problems. After the legendary Two Sum, let’s tackle the next one: Problem #2 — Add Two Numbers.

You can visit my LeetCode repo in my github 👇

https://github.com/mahdi0shamlou/LeetCode

This is a Medium difficulty problem, but it’s an absolute classic — it shows up a lot in coding interviews at big tech companies. Solving it well proves you’re comfortable with linked lists, pointer manipulation, and handling carry like in elementary school addition.

Problem Statement: Add Two Numbers

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each node contains a single digit.

Add the two numbers and return the sum as a linked list (also in reverse order).

Examples

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807

Input: l1 = [0], l2 = [0]
Output: [0]
-------------------------
Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
Output: [8,9,9,9,9,9,9,1]
Explanation: 9999999 + 9999 = 10009998

A Cool & Unique Approach: Recursive Solution

The most common way is iterative (using a dummy node and carry), which is super efficient and safe. But today, I want to share a more interesting and elegant recursive approach that I came up with — it’s less common, feels very functional, and beautifully mirrors how we think about addition digit-by-digit while propagating the carry.

The idea is simple:

We create a helper recursive function that takes the current nodes from both lists and the carry from the previous digit.
Add the values + carry, compute the new digit (% 10) and new carry.
Recursively compute the next node.
Handle cases where one list is longer by passing a dummy node with value 0.
Base case: when both lists end and no carry left, return None.

Here’s my Python solution:

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        return self.sum(l1, l2, 0)

    def sum(self, l1, l2, added):
        posetive = l1.val + l2.val + added
        added = 0
        if posetive >= 10:
            posetive = posetive - 10
            added = 1

        if l1.next != None and l2.next != None:
            list_node = ListNode(val=posetive, next=self.sum(l1.next, l2.next, added))
        elif l2.next == None and l1.next != None:
            list_node = ListNode(val=posetive, next=self.sum(l1.next, ListNode(val=0, next=None), added))
        elif l2.next != None and l1.next == None:
            list_node = ListNode(val=posetive, next=self.sum(ListNode(val=0, next=None), l2.next, added))
        else:
            if added:
                list_node = ListNode(val=posetive, next=ListNode(val=added))
            else:
                list_node = ListNode(val=posetive, next=None)

        return list_node

Why this recursive approach is interesting:

Elegant and intuitive — recursion naturally handles the “go to next digit” flow.
Clean structure — no dummy nodes or while loops; the recursion tree builds the result bottom-up.
Performance — O(max(n, m)) time and space, beats many submissions.

That said, for very long lists (up to 100 nodes), Python’s recursion depth might be a concern, so iterative is safer in production. But this recursive version is super fun and impressive in interviews if you explain the edge cases well!

If you prefer the standard iterative way or know other tricks, share in the comments! I’d love to hear and maybe cover them in a follow-up 🚀

Any questions? I’m happy to help!

Connect with me:

🔗 LinkedIn: https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram: https://telegram.me/mahdi0shamlou

📸 Instagram: https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو

Mahdi Shamlou | Solving LeetCode #1: Two Sum — The Classic Hash Map Solution

Mahdi SHamlou | مهدی شاملو — Fri, 23 Jan 2026 16:38:08 +0000

Hey everyone! I’m Mahdi Shamlou, and I’m starting a new series on classic LeetCode problems. Let’s kick it off with the very first one: Problem #1 — Two Sum.

This is an Easy difficulty problem, but it’s legendary — it’s often the very first question in coding interviews at big tech companies. Solving it optimally shows you understand one of the most powerful tools in programming: hash maps (dictionaries in Python).
Problem Statement: Two Sum

Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target.

You may assume that each input has exactly one solution, and you may not use the same element twice. You can return the answer in any order.

Examples:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: nums[0] + nums[1] = 2 + 7 = 9

Input: nums = [3,2,4], target = 6
Output: [1,2]

Input: nums = [3,3], target = 6
Output: [0,1]

The Optimal Approach: One-Pass Hash Map

The brute force way would be to check every pair with two nested loops — that’s O(n²) time, which is too slow for large arrays.

Instead, we use a dictionary to store numbers we’ve seen so far and their indices.
Become a member

As we iterate through the array:

For each number nums[i], calculate the target_less:
target — nums[i] 0 If the target_less is already in the dictionary, we’ve found our pair!
Otherwise, add the current number and its index to the dictionary.
This is one pass through the array → O(n) time and O(n) space.

Here’s the Python solution:

class Solution(object):
    def twoSum(self, nums, target):
        dict_key = {}

        for i, num in enumerate(nums):
            target_less = target - num

            if target_less in dict_key:
                return [dict_key[target_less], i]

            dict_key[num] = i

Why is this approach great?

Super efficient: Beats 95%+ of submissions on LeetCode in time
Clean and readable: Easy to explain in interviews
Handles edge cases perfectly : like duplicate numbers

If you know other methods feel free to share in the comments! I’d love to learn and maybe create a separate post about them 🚀

Any questions? I’m happy to help!

Connect with me:

🔗 LinkedIn: https://www.linkedin.com/in/mahdi-shamlou-3b52b8278

📱 Telegram: https://telegram.me/mahdi0shamlou

📸 Instagram: https://www.instagram.com/mahdi0shamlou/

Author: Mahdi Shamlou | مهدی شاملو