DEV Community: Seif Ahmed

Why I built Vlox with Node.js, Cash, and MongoDB

Seif Ahmed — Thu, 22 Oct 2026 19:03:02 +0000

Hey guys! 👋🏻

I've been sharing a lot lately about my social media app, Vlox, but I haven't explained why I chose to create Vlox in Node.js and why I used Cash instead of a heavy modern framework like React. Today I'm going to tell you why.

Current tech stack

The core of Vlox is straightforward:

Backend: Node.js and Express (for its asynchronous, non-blocking architecture)
Frontend: Cash (a tiny, lightweight jQuery alternative)
Database: MongoDB with Mongoose (because I wanted to use schemas as blueprints for the data structure)

Why Cash over React or Vue?

Most devs immediately reach for React, Vue or other modern frameworks when starting a social app. But I chose Cash for two major reasons:

To prove that you don't need traditional tools to build something clean, functional, and secure.
And to keep my app lightweight. Frameworks like React bring a lot of weight and bloat with them.

Since I'm not planning to make Vlox a massive platform like Facebook, I don't need to worry about complex scaling issues. Keeping the scope focused allows me to prioritize simplicity over enterprise-level architecture. Perfecto 👌🏻

Why MongoDB instead of SQL?

Choosing MongoDB over a relational SQL database came down to how the app actually works.

First, Vlox doesn't need database JOINs. For example, I don't need complex queries to find "friends of friends" because Vlox doesn't have a friends feature; it's a content and community network like DEV. Even when fetching post authors, I rely on Mongoose references and field population. This works perfectly for mid-sized apps, though SQL is a better fit for large relational data. In the end, large social media apps usually rely on a hybrid approach:

SQL for user profiles, authentication, core relational data, and transactional records.
And NoSQL (like MongoDB, Redis, etc...) for caching, real-time notifications, session tokens, and high-speed feed lookups.

Second, the entire backend runs on Node.js. Because MongoDB uses a JSON-like format, it works smoothly out of the box with JavaScript-heavy stacks.

I would really love to hear what you think about this approach. Drop a comment below if you have any questions about using Cash or building without the usual heavy frameworks!

Thanks for reading! 🌟

How Binary Search Actually Works: A Deep Dive 🔍

Seif Ahmed — Sat, 17 Oct 2026 17:03:47 +0000

Hey guys! 👋🏻

In my last article, I talked about one of the most basic sorting algorithms: Bubble Sort. Bubble Sort is a fundamental algorithm used to sort data. It works by repeatedly stepping through a list, comparing adjacent elements and swapping them if needed. But what if we want to find a target within our sorted collection? There are several algorithms we can use, and today, we're going to look at one of the most efficient: Binary Search.

What is Binary Search?

Binary Search is a powerful algorithm designed to find the position of a target value within a sorted collection. It relies on the Divide and Conquer approach, cutting the remaining search space in half with each step. Trust me, that's much better than the slow linear search 😅

The little prerequisite

For binary search to work, the search space must be sorted or monotonic (consistently increasing or decreasing). If the data is sorted randomly, you can't discard half of the search range.

How it works

Binary search tracks the search space using two index pointers: low/left (the start of the range) and high/right (the end of the range). It then executes simple logical steps:

Init low = 0 and high = N - 1. N is the length of the items in your dataset.
Calculate the middle index (mid) of the current range.
Compare the element at mid with your target value:
- Matching case: If the element at the mid index matches your target, you've found it. Return mid.
- Target is smaller: If the element at the mid index is greater than your target, the target might be in the left half. Narrow your search space by updating the upper boundary: high = mid - 1.
- Target is larger: If the element at the mid index is smaller than your target, the target might be in the right half. Narrow your search space by updating the lower boundary: low = mid + 1.
Repeat steps 2 and 3 as long as low <= high. If low surpasses high, the target is not in the array, and you should return a value like -1 to signal that nothing was found.

Example implementation

Let's write a JavaScript implementation of this algorithm. I'll keep it simple with no noise or clutter.

function binarySearch(arr, target) {
  if (!Array.isArray(arr)) {
    throw new TypeError("Input must be a valid array.");
  }

  let low = 0;
  let high = arr.length - 1; 

  while (low <= high) {
    // a safe way to find the middle index without risking integer overflow 
    // in languages like Java or C++. I know we are using JavaScript here, 
    // but the concept behind this approach is good to know
    const mid = low + Math.floor((high - low) / 2);
    const current = arr[mid];

    if (current === target) return mid; 
    else if (current > target) high = mid - 1; 
    else low = mid + 1;
  }

  return -1; 
}

In our code above, we used an inclusive upper bound, meaning the index high is included in our search loops. Some developers prefer to use an exclusive upper bound where high = arr.length. If you choose the exclusive approach, you just need to tweak your loop condition to while (low < high) and update your right-side boundary shift to high = mid. Both approaches work well, but the exclusive upper bound is better for things like finding where to insert a missing item.

Example use

Now, let's test our function. We will try to find the target number 7 in this sorted array: [1, 3, 5, 7, 9].

Iteration 1:
- Current boundaries: low = 0, high = 4
- Calculating the middle index: mid = 0 + Math.floor((4 - 0) / 2) = 2
- Element at mid (index 2) is 5.
- Compare 5 and target 7. 5 < 7, so our target might be in the right half.
- Update lower boundary: low = mid + 1 = 3.
Iteration 2:
- Current boundaries: low = 3, high = 4
- Calculating the middle index: mid = 3 + Math.floor((4 - 3) / 2) = 3
- Element at mid (index 3) is 7.
- Compare 7 and target 7. They match!

We just did it! 🎉 Our function will successfully stop right here and return the index 3.

And that's Binary Search for you! It's a simple logic change that makes a massive difference in performance once your arrays start getting big.

See you in the next article, where we will be looking into Merge Sort! ✨

I'm 13. I Built a Secure Social Network with Node.js 👨🏻‍💻

Seif Ahmed — Sat, 17 Oct 2026 11:20:02 +0000

Hey dev community! 👋🏻

I'm Seif, a software engineer with 4 years of experience who absolutely hates vibe-coding and prefers designing architecture by hand. 👨🏻‍💻

When I initialized the repository for my project, Vlox, my mission was simple: build a clean, fast developer social network and prove that anyone can build safe web apps without heavy client-side frameworks like React.

Today, the app is fully hosted and live at https://vlox.containers.snapdeploy.app (the initial load may take 60 to 90 seconds due to a cold start 😅)

The tech stack

Instead of standard enterprise software, I picked lightweight tools to power Vlox:

Backend: I chose Node.js because its asynchronous, non-blocking nature makes it great at handling many requests simultaneously on a single server.
Frontend: Cash (a tiny, 3KB DOM manipulation library that mirrors jQuery syntax) paired with classic server-side data handling. Since I don't plan to make Vlox a massive app, this choice is fine.
Database: MongoDB via Mongoose. Since Vlox doesn't need JOINs, choosing SQL was unnecessary. Plus, MongoDB works great with JavaScript stacks because of its JSON-like format.

One of my engineering decisions: Using transaction

When building Vlox, I had to make engineering decisions to handle features like post likes.

On every like, the likes field in the post doc increments by 1 using updateOne for atomicity and a new document with a unique index is added to the likes collection.

Some developers might skip transactions here, but that can cause sync problems. If the server crashes, runs into an error, or loses its connection right after the $inc step but before saving the new like, the data gets broken.

The like count on the post will be higher than the actual number of likes in the collection. Even worse, because there is no record to prove the user already liked it, they can hit the like button again and fake the count.

That's why I chose to put both steps inside a transaction. If one part fails, everything goes back to normal automatically. Also, MongoDB checking the unique index across docs won't cause performance issues because Vlox isn't meant for hundreds of thousands of people yet. When engineering, you just need to make the right choices for your specific app scale. Perfecto 👌🏻

Check out the code

Vlox is completely open source, and I'm happy to answer your technical questions. You can also inspect the code at https://github.com/Hfs2024/Vlox

I would really love your honest feedback. Please consider sharing it in the comments below!

Thanks for reading! 🌟

Everything You Need to Know About Bubble Sort 🫧

Seif Ahmed — Fri, 16 Oct 2026 09:31:14 +0000

Hey dev community! 👋🏻

I'm Seif, a software engineer with 4 years of experience specializing in Node.js, JavaScript and MongoDB. Today, I chose to start a new series that teaches you computer science algorithms for learning and interview preparation. In this article, I'm going to teach you the absolute, most basic sorting algorithm: Bubble Sort.

What is Bubble Sort?

Bubble Sort is a fundamental sorting algorithm that works by repeatedly stepping through a list, comparing adjacent elements and swapping them if they are in the wrong order. The algorithm gets its name because smaller or larger elements bubble to the top (the end of the list) with each pass. Think of it like gas bubbles rising in a liquid!

How it works in detail

Bubble Sort works by using nested loops to iterate through an array. It can sort items in ascending or descending order. For now, let's focus on sorting items in ascending order.

Start at the beginning of the array. Compare the first two elements (at index 0 and index 1).
If the first element is greater than the second element, swap them. If not, leave them as they are.
Move to the next pair of elements (at index 1 and index 2) and repeat the comparison.
Continue this until you reach the end of the array. By the end of the first pass, the largest element will have migrated to the last position.
Repeat the entire process for the remaining unsorted elements. Each pass places the next largest element into its correct final position.

Complexity

Bubble sort is rarely chosen for production use because it is slow. On average and in the worst-case scenario (when the array is reversed), its time complexity is quadratic. In the best case, it can achieve linear time complexity. Also, because it sorts in-place, its space complexity is constant. Perfecto 👌

Example implementation

Let's design a modern JavaScript implementation of this algorithm. We will focus on sorting numbers, even though the algorithm can be used to sort other data types, such as alphabetizing strings. I also used validation checks like Array.isArray() to prevent unexpected crashes if a developer accidentally passes a non-array arg.

function bubbleSort(arr) {
  if (!Array.isArray(arr)) {
    throw new TypeError("Input must be a valid array.");
  }

  // Validation
  if (!arr.every(Number.isFinite)) {
    throw new TypeError("Array must contain numbers only.");
  }

  // Clone the array for immutability
  const sorted = [...arr];
  const n = sorted.length;

  for (let i = 0; i < n - 1; i++) {
    let swapped = false;

    for (let j = 0; j < n - i - 1; j++) {
      const current = sorted[j];
      const next = sorted[j + 1];

      // Compare and swap
      if (current > next) {
        [sorted[j], sorted[j + 1]] = [next, current];
        swapped = true;
      }
    }

    if (!swapped) {
      break;
    }
  }

  return sorted;
}

We use arr.every(Number.isFinite) upfront instead of validating numbers inside the nested loops for resource efficiency and preventing wasted work (if an array contains 1000 elements and the very last element is a string, an in-loop check will waste time sorting the first 999 items before finally crashing).

Example use

Now, we are ready to test our function. Let's use it to sort this array: [5, 1, 4, 2].

Pass 1:
- Compare 5 and 1. 5 > 1, so swap. Now the array is: [1, 5, 4, 2]
- Compare 5 and 4. 5 > 4, so swap. Now the array is: [1, 4, 5, 2]
- Compare 5 and 2. 5 > 2, so swap. Now the array is: [1, 4, 2, 5]
Pass 2:
- Compare 1 and 4. 1 < 4, so no swap. Now the array is: [1, 4, 2, 5]
- Compare 4 and 2. 4 > 2, so swap. Now the array is: [1, 2, 4, 5]
Pass 3:
- Compare 1 and 2. 1 < 2, so no swap. Now the array is: [1, 2, 4, 5]

We just did it! 🎉 Our final sorted array is: [1, 2, 4, 5]

Pros and cons of Bubble Sort

Bubble Sort is a great algorithm for learning, but it has many disadvantages, that's why we should avoid it in production.

Advantages

Simplicity: Incredibly easy to understand and write.
No Extra Memory: Generally, it performs sorting in-place, but because our implementation above clones the array to ensure immutability, its space complexity is linear.
Detects Sorted Lists quickly: With optimization, it stops instantly on a sorted list.

Disadvantages

Bad Efficiency: A quadratic time complexity makes it slower for large datasets compared to Merge Sort or Quick Sort.
Excessive Swapping: It writes to memory frequently due to constant swapping, which can be mechanically costly.

That is my wrap on Bubble Sort! While it is rarely used in production code, mastering it gives you foundational algorithmic thinking!

See you in the next article, where we will transition from sorting data to finding it fast using Binary Search.

Thanks for reading! 🌟

Why 90% of Coding Isn't Syntax 💻

Seif Ahmed — Sat, 10 Oct 2026 05:27:49 +0000

If you've spent any time online lately, you've probably seen people panicking about AI taking over tech. AI isn't stealing your job—it's just taking over the boring parts.

Syntax is cheap, logic is everything

An LLM is basically just an advanced autocomplete engine guessing the next likely word.

When you ask an AI for standard boilerplate code or a basic algorithm, it works instantly. But coding is about 10% syntax and 90% logic. Syntax is just how you talk to a computer; knowing a language doesn't make you an engineer. The hardest parts involve figuring out user needs, designing data flows, and handling edge cases. Give an AI a unique problem outside its training data, and it will just hallucinate.

What happens in production

An AI can write a hundred lines of code instantly, but it won't be on call at 3:00 AM when a memory leak crashes your database.

You are the one responsible for security and fixing real-world vulnerabilities. Live systems care about surviving actual users and messy networks, not how fast the code was generated.

Why AI is still an awesome sidekick

AI is still an incredible tool when used correctly:

It helps you build things faster.
It helps you learn new concepts.
It acts as a great sounding board when you're stuck.

Real engineering decisions will always belong to humans, no matter how much AI improves.

Thanks for reading ✨!

I Created My X Account 🐦

Seif Ahmed — Wed, 26 Aug 2026 06:27:25 +0000

I just created my X (Twitter) account to document my journey, share open-source updates, and connect with other developers.

If you want to support me or just talk about tech, let's connect:

👉 Follow me on X:

Seif Ahmed (@seifahmedcoding) / X

Creator of Vlox — the ultimate social network!

x.com

I'm actively following back everyone from the DEV community who hooks up with me there. Drop your X handle or your latest side project in the comments below so I can check out what you are building too!

I Built a New Social Network. Try to Crash It 💥

Seif Ahmed — Mon, 03 Aug 2026 07:11:13 +0000

Let’s be honest: building a social media app is usually a massive headache.

I really wanted to see how far I could push modern web architecture and deployment efficiency while keeping my app lightweight.

The result is Vlox, and it’s live right now if you want to check it out:
👉 vlox.containers.snapdeploy.app

How I built it

I decided to keep everything lightweight. That means zero React, zero Next.js, and absolutely no heavy state management tools bloating the client side.

Frontend: 100% Vanilla JS driven by Cash—a tiny, open-source library designed as an absurdly small alternative to jQuery for modern browsers. I chose it over heavy frameworks because I prioritize lightweight code and have no plans to make this a massive app.
Backend: Pure Node.js and Express doing the heavy lifting.
Database: MongoDB with Mongoose keeping the data models straight.
Deployment: Containerized microservices.

The challenge: Help me break it!

I’ve done my best to optimize the the container, but local testing only gets you so far. To really see what this setup can handle, I need raw traffic from real users.

Head over to https://vlox.containers.snapdeploy.app.
Create an account and write a few posts.
Keep your network tab open! Let me know if you spot any bottlenecks, sluggish queries, or obvious memory leaks.

If you like the architecture and want to support the project, please consider starring the the repo on GitHub!

Thanks for reading!

[Boost]

Seif Ahmed — Fri, 10 Jul 2026 05:37:13 +0000

Seif Ahmed

Jul 9

Building a Secure Authentication System

#tutorial #webdev #authjs #programming

1 min read