Good night ppl 🫡

Day 1/30 — I thought I understood Node.js… until I didn’t

I’ve built APIs.
Used Express.
Handled async/await.

But recently, I realized something. i was using Node.js but not actually understanding it.
Most of us write code like this daily:
- Fetch data from DB
- Call APIs
- Return responses And everything works…

But here’s the problem 👇
⚠️ We rarely think about:
- What happens under the hood?
- How requests are actually handled?
- Why Node.js scales so well?

# Reality check:
If your app suddenly gets:
- 1,000+ requests per second
Would your current knowledge hold up?
Or would things start breaking?
That’s why I’m starting this challenge.

Not to learn syntax - But to understand the system behind the code.

* Day 1 takeaway:

Writing Node.js code is easy.
Understanding how it behaves under pressure is what makes you a real backend engineer.

Tomorrow I break down the Event Loop in a way that finally makes sense..

Follow along if u're serious about mastering backend :}

@devcap12
#30dayschallenge #nodejs #BackendDev

I really enjoy putting my thoughts into words. There’s something about writing them down that makes everything feel clearer, more real, and easier to understand. It helps me slow down, reflect, and make sense of whatever’s on my mind.

So I ended up building my own journaling site called Memora 🌙

It’s basically a small journaling space I made for myself… but yeah, sharing it here too.

Key features:
⚡️Organizes your entries based on your mood
⚡️Has a streak system to keep you consistent
⚡️Customizable colors & fonts


Still improving it as I go, but it’s already something I genuinely enjoy using.

Try it out!

Hope you enjoy it too :)

Day 2/30 - The Secret Sauce of Node.js(The Event Loop)

Why node feels fast even though it’s "lazy" ahh🤔
Yesterday, I admitted I was using Node.js without actually knowing it. Today, we fix the biggest mystery The Event Loop.
If you understand this, u understand Node.js. Period!!!!

🧐 The Big Paradox
Node.js runs on a single thread. Just one. How can one single thread handle 10,000 users at once without crashing??
The Answer is simple. The Event Loop + Non-blocking I/O

Node.js doesn’t work harder instead it works smarter. It’s the master of delegation.
** The "Smart Waiter" Analogy, Imagine a restaurant with only one waiter (Node.js) but a huge kitchen staff (the Operating System/Thread Pool).
— The Order: u order a steak (a slow Database query).
— The Delegation: The waiter doesn’t stand at the kitchen window waiting for the steak to cook. He drops the order off and immediately goes to take a drink order at Table 4.
— The Callback: When the steak is ready, the kitchen rings a bell .
— The Delivery: The waiter finishes pouring that drink, hears the bell, and brings the steak to ur table.
# Result: No one is left waiting at the door, and the waiter is always moving.

# The Lifecycle of a Request:
1. Request hits: Node checks if it's heavy.
2. Heavy lifting? (DB, File System, API call) -> Node says ''You handle this'' to the system and moves on.
3. Execution: Node keeps handling new visitors.
4. Completion: When the heavy task is done, it joins a "waiting line" (Callback Queue).
5. The Loop: The Event Loop constantly checks: ''Is the main thread free? Yes? Okay, bring in the next finished task!''

# Why this is a Game Changer
This architecture makes Node.js the king of:
— Real-time apps like chat and Game..
— Streaming..
— APIs with massive traffic

# The Golden Rule
Don't block the loop. If you write a heavy mathematical calculation directly in the main thread, the "waiter" stops moving. No one gets their food. The app freezes.

* Day 2 Takeaway:
Node.js isn’t fast because it’s a powerhouse; it’s fast because it never waits for anyone.

Tomorrow We look at "Blocking vs. Non-blocking" with actual code. See u then 🫡


@devcap12
#30dayschallenge #nodejs #BackendDev

Dont confuse education with intelligence comrades , you can have a PhD and still be an idiot.

Introducing AddisFriendBot Version 2:

• Fully anonymous 1-to-1 chats — no Telegram IDs exposed
• Unique Friend ID system for reconnecting anytime
• Location-based matching (within 100km) without revealing exact position
• Simple flow: search → pick location → get matched → start chatting
• Improved privacy-first design across the whole experience

Now you can meet new people across Ethiopia while staying completely private

try it: t.me/AddisFriendBot

Day 3/30 — BLOCKING vs NON-BLOCKING

The mistake that kills Node.js performance Node.js is fast… But many developers accidentally make it slow.

* The reason?
< Blocking code. />
Let’s break this down simply.

# There are 2 ways your code can run:-

❌ Blocking (Bad for Node.js)

— One task runs
— Everything else waits
— App becomes slow under load

Ex:- Reading a file synchronously 👇

const data = fs.readFileSync('file.txt',  'utf-8');
console.log(data);

Problem is Node.js stops everything until this finishes
✅ Non-blocking (Node.js way)

— Tasks are delegated
— App keeps running
— Handles multiple users smoothly

fs.readFile('file.txt', 'utf-8', (err, data) => {
  console.log(data);
});

* Node.js sends the task —> keeps working —> comes back later
# Real-world impact:
- Imagine 1000 users hitting your API:
❌ Blocking —> requests pile up —> slow or crash
✅ Non-blocking —> smooth handling —> better performance

Here’s the truth. Node.js doesn’t magically scale… u've to write code that respects its design!!!

# Day 3 takeaway:-

Node.js gives you speed
Blocking code takes it away

Tomorrow —> Async/Await vs Promises (what most Devs still misunderstands).....


@devcap12
#30dayschallenge #nodejs #BackendDev

The lecturer who bets on students — with his own wallet.

This Saturday at 2:00 PM LT, HUDC Podcast welcomes a guest who's shaped CCI from the classroom to the codebase:

Mr. Gizachew Belayneh

No titles can capture his impact. But his story can.
Before Saturday:
🎥 Watch What Matterስ! on YouTube for a taste of his insights
💻 TechMatters.et — His company: Training, consultancy & web solutions

Join us live. Bring your questions. Leave inspired.

🗓 Saturday | 2:00 PM LT
📲 Join: link for the live session
💼 Follow HUDC: LinkedIn

Day 4/30 — Async/Await vs Promises

If u use Node.js, u’ve written this, it's clean, Simple. Easy.

await getUser();

But here’s the truth. async/await is just a wrapper around Promises. Let’s break it down properly:-

# Promises (the foundation)

getUser()
  .then(user => getPosts(user.id))
  .then(posts => console.log(posts))
  .catch(err => console.error(err));

—> Works fine… but:
- Harder to read
- Becomes messy with multiple chains

# Async/Await (syntactic sugar)

try {
  const user = await getUser();
  const posts = await getPosts(user.id);
  console.log(posts);
} catch (err) {
  console.error(err);
}

—> Looks synchronous
—> Easier to reason about
But here’s what most Devs didn’t realize about, Async/Await can still be inefficient if used wrong.

❌ Common mistake:

const user = await getUser();
const posts = await getPosts(user.id);

These run sequentially...

✅ Better approach (parallel execution):-

const [user, posts] = await Promise.all([
  getUser(),
  getPosts()
]);

Runs both at the same time faster..
# Key insight:
Async/Await improves readability
But Promises control execution behavior..


# Day 4 takeaway:

Don’t just write cleaner code..
Write faster and smarter async code...

Tomorrow —> Streams in Node.js.... how big apps handle huge data and others mor..


@devcap12
#30dayschallenge #nodejs #BackendDev

🔴 WE'RE LIVE

Mr. Gizachew Belayneh is on the mic right now.

Join the conversation while it's happening.

📍 Tap in: link

Got a question? Drop it below 👇

🚀 We’re forming a DSA Learning community
(inspired by Blue Nile DSA community)

Staying consistent alone is hard, so we’re building a peer-driven community where small teams push each other to grow.

This isn’t a course or a place where someone teaches you everything.
Instead, you’ll be part of a team of 7, where you:

👨‍💻 Solve problems together daily
💬 Discuss approaches and learn from each other
🎤 Do weekly rotating presentations (1 person per day)
📈 Stay accountable and consistent

We’ll mainly use Python, working toward:
💼 Technical interviews
🏆 Competitive programming
🌟 Opportunities like A2SV

📅 Starts this summer

If you’re ready to stay consistent and improve with others, this is for you.

📝 Apply here: Registration Link

⚠️ Spots are limited since teams are small, apply early to secure your place 🔥

Day 5 update… yeah, I owe y’all a quick one...
I slipped a bit and missed yesterday got caught up in class assignments and some urgent project mnamn stuff. Not gonna lie it was hectic, but that’s life sometimes. still no excuses i’m locked back in. this challenge means a lot to me, and i’m not about to let one missed day kill the vibe.

# Appreciate everyone who’s been following n supporting y’all the real MVPs 🙌
We move forward, no looking back.

Day 5 coming in hot :}

@devcap12

Day 5/30 — Streams in Node.js.... one of the most underrated concepts)

At first, I used to read files like this...

const data = fs.readFileSync("large-file.txt", "utf-8");

It works… until the file becomes huge. That’s when I realized why Streams are so powerful.
# What problem do streams solve?
Normally, when you read a file, Node.js loads the entire file into memory.
For small files —> fine ✅
For large files —> dangerous ❌
Because memory usage increases fast.

# Streams solve this by processing data piece by piece (chunks). Instead of loading everything at once, Node.js reads it gradually.

*** Think of it like this:-
❌ Normal file read = download the whole movie first
✅ Stream = watch while it’s still loading

Ex:-

const fs = require("fs");

const stream = fs.createReadStream("large-file.txt", "utf-8");

stream.on("data", chunk => {
  console.log(chunk);
});

👉 Here, data comes in smaller chunks
👉 Less memory usage
👉 Better performance

# Why this matters in real-world backend apps

Streams are used in:
- File uploads
- Video streaming
- Large CSV processing
- Logs & real-time data pipelines
This is exactly how apps handle huge amounts of data efficiently.

# Day 5 takeaway:-

Streams are not just about files
They are about efficient data flow ;)

Note that if u understand streams, u start thinking like a system designer :}

Tomorrow —> Middleware in Express - the secret flow behind every request,.,


@devcap12
#30dayschallenge #nodejs #BackendDev

Gebeta Maps is an Ethiopian-based provider of mapping and location-based services, founded in 2021 to offer affordable, reliable GIS, API, and routing solutions tailored for the African continent. It provides developers and businesses with tools like geocoding, route optimization, and map tiles, with a focus on local data.

And now, we are about to release a localized, easy to use and up-to-date mobile app. Stay tuned.

Our Social Links:
Instagram: ig.me/gebetamaps
Linkedin: linkedin.com/company/gebetamaps
X/ Twitter: x.com/gebetamaps
Telegram: t.me/gebetamaps
Web: gebetamaps.com

LoL 🤣🤣
ayne nw weyss bire nw wegen👀😳

guys @misscoder101 left with 3 members to hit 400 sub.. ena let's gooooo enimulalat ✌️

Day 6/30 — Middleware in Express, the invisible flow behind every request

At first, I used Express like this 👇

app.get("/users", (req, res) => {
  res.send("Users data");
});

Simple. Works. But as the app grows, u quickly need more..
- Authentication
- Logging
- Validation
- Error handling
That’s where middleware come.. b/c the real backbone of ur API

# What is middleware?
Middleware is simply a function that runs b/n the request and the response. Think of it like a checkpoint system:-

Request → Middleware → Route → Response

Ex:-

app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next();
});

👉 Every request passes through this first
👉 Then moves to the next step using next()
# Why it’s powerful??
Instead of repeating code in every route ❌

app.get("/users", ...);
app.get("/posts", ...);
app.get("/profile", ...);

u centralize shared logic ✅

For ex:- auth middleware 👇

const auth = (req, res, next) => {
  if (!req.headers.token) {
    return res.status(401).send("Unauthorized");
  }
  next();
};

Use it like this:-

app.get("/profile", auth, (req, res) => {
  res.send("Private profile");
});

Real-world use cases, Middleware is perfect for:-
- JWT authentication
- Request logging
- Input validation
- Rate limiting
- Error handling
This is where your backend starts feeling professional...

# Day 6 takeaway:-

Middleware keeps your API clean, reusable, and scalable. It’s not just a feature of Express, it’s the request flow architecture :}

Tomorrow —> Error handling in Node.js APIs... how production apps stay stable.,.



@devcap12
#30dayschallenge #nodejs #BackendDev

Morning fam :}

We launched the LinkedIn Changemaker Awards Ethiopia 2026 to recognize Ethiopians creating real impact through knowledge sharing, career growth, and community influence on LinkedIn.

This initiative highlights individuals and organizations shaping Ethiopia’s professional space with consistent value.

The platform is now live:-
https://changemakeraward.com

It features 22 categories across areas like career development, health, mental health, climate, and more, all focused on impact.

Behind this platform is a full process we built from the ground up:
• Public nominations
• Careful review and shortlisting
• Final voting by the community

We worked across technical, creative, and operational levels to make this happen and deliver something meaningful for Ethiopia.

Now it’s your turn.
Vote. Support. Amplify impact.

Let’s make recognition meaningful.

⏳ 3… 2… 1… The next chapter is almost here.

Before we move forward, we honor where we began. As HUDC, we met incredible developers, shared breakthroughs, and built a space where curiosity thrived. Every discussion and milestone is part of our history—never forgotten. Thank you to everyone who helped shape it.

As we grew, we realized our name might unintentionally limit us. Our vision is bigger: to reach anyone with that spark for tech. Started in the East, we’re proudly carrying that origin with us as we step beyond university walls into a wider, inclusive space.
That's why we're evolving into:

ESDA — East Spark Devs Association

The logo above marks this new era. (Design story coming soon!)

📢 This channel's name will update to ESDA soon. You'll see the change reflected here first.
💬 What do you think of the logo? Drop your thoughts below 👇

Same heart. More energy. Let's ignite the next phase. 🔥
#HUDC #ESDA #EastSparkDevs #HUDCLegacy #TechCommunity #FromCampusToBeyond #NextChapter

Day 7/30 — Error handling is what separates demos from production APIs

A route that works in local development is easy. A route that fails gracefully in production??

# The common beginner approach

app.get("/users/:id", async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user);
});

Looks clean. But what happens if:-
- the database is down?
- the ID is invalid?
- the query throws an exception?
ur API crashes or returns confusing errors right....

# Production mindset
Every request can fail. ur job is to make failure predictable and readable..

—> Use try/catch for async routes :-

app.get("/users/:id", async (req, res) => {
  try {
    const user = await User.findById(req.params.id);

    if (!user) {
      return res.status(404).json({
        message: "User not found"
      });
    }

    res.json(user);
  } catch (error) {
    res.status(500).json({
      message: "Internal server error"
    });
  }
});

* Now the API stays stable... Better centralized error middleware

# below are how real apps scale:-

app.use((err, req, res, next) => {
  console.error(err);

  res.status(500).json({
    success: false,
    message: err.message || "Something went wrong"
  });
});

Now every route can forward errors:-

next(error);

⚡️ Why this matters

Good error handling gives u:-
- stable APIs
- clean responses
- easier debugging
- better frontend integration
Because frontend teams need consistent error shapes,.,

# Day 7 takeaway

- A good backend developer doesn’t prevent every error. they design systems that fail safely. that’s production thinking :}

Tomorrow —> JWT Authentication in Node.js and we gonna see real-world secure APIs :}



@devcap12
#30dayschallenge #nodejs #BackendDev