🔴 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

Here we are... first week is done bezenezena 🫡

Ethio Ministry
Something BIG is about to land... and trust me, u don’t wanna miss this!!!

We’re cooking up something powerful for Grade 7 & 8 students— Ethio Ministry is coming soon.. Imagine having real past exams from Addis Ababa, Oromia, Dire Dawa, and Harar right in your pocket, combined with clean explanations that actually make things click (no more guessing vibes). From textbook to smart practice and progress tracking, everything is built to help students move from "I think I know this" to "I got this 💯".
And yeah... the best part? It works offline too :} so whether u’re online or not, ur learning never stops. This is student full exam partner, designed to help students study smarter, not harder.
Built with passion by Hegere Technology, n proud to say I was part of the mobile app development team that brought this to life :}

This is more than just an app, t’s a whole upgrade to how students prepare and succeed.

⏳ It’s almost here.. Stay locked in... Ethio Ministry is coming to Play Store VERY SOON! 🚀

WEEK 1 RECAP — 7 Days of Node.js and Let's see 7 Shifts in Mindset :}


Within this first week/7-days i didn’t just revisit Node.js concepts.. i just started seeing how systems actually behave under the hood,,,,

#Day 1 — From Using Node.js to Understanding It
I realized something uncomfortable. I had been using Node.js for a while, but not truly understanding how it works internally. The shift was this:
- Writing routes is easy
- Understanding runtime behavior is engineering
That was the real starting point.

#Day 2 — Event Loop a;so we can call it the Heartbeat of Node.js,.,
This was the first major mindset shift. Node.js feels fast not b/c it’s multi-threaded But because it doesn’t waste time waiting. The event loop taught me that performance is often about delegation, not raw power.
Heavy I/O tasks are pushed away, while the main thread keeps serving work
That’s elegance :)

#Day 3 — Blocking vs Non-Blocking
This concept hit hard. Node.js gives u speed by design
but ur code can destroy that speed. A single blocking call can freeze the entire request flow
That means performance is not just framework-level
It’s developer responsibility. This is where I started thinking in terms of runtime pressure :}

#Day 4 — Async/Await vs Promises
This was less about syntax and more about execution behavior
The biggest lesson?
Clean-looking code can still be slow. Sequential awaits may look elegant but parallel execution often performs far better..
This is where readability meets performance thinking :}

#Day 5 — Streams
Streams changed the way I think about memory. Before now I thought data = load → process → return. Now I think in continuous flow.
Data doesn’t always need to exist fully in memory Sometimes the smartest system is the one that processes in motion. That’s how scalable systems think

#Day 6 — Middleware
This was where API structure started making sense. Middleware taught me that backend systems are not just routes.
There are **pipelines ->
Authentication
validation
logging
rate limits
Everything becomes a controlled request flow. This is architecture inside the application layer.

#Day 7 — Error Handling
Production systems are judged by how they fail.
Graceful failures
predictable responses
centralized error control
This is what separates projects from systems!!

*** My biggest realization from Week 1
Backend development is not only about code It’s about:-
- flow
- behavior
- failure
- scale
- architecture
And that’s the mindset I want to keep building :}

In the will of God Week 2 gets even deeper 🫡

@devcap12
#30dayschallenge #nodejs #BackendDev

Day 8/30 — JWT Authentication. how real-world login APIs work??

Authentication is one of the first things every backend developer builds.nBut many people stop atmUser logs in successfully. The real question is how does the server remember the user afterward??
That’s where JWT comes in 🔐

@ What is JWT??
JWT = JSON Web Token
After login, the server creates a signed token that contains user information, such as:-

{
  "userId": "12345",
  "role": "admin"
}

This token is sent back to the client and stored there.
Every future request includes it 👇

Authorization: Bearer <token>

# Real login flow

1️⃣ User logs in

app.post("/login", async (req, res) => {
  const user = await User.findOne({ email: req.body.email });

  const token = jwt.sign(
    { userId: user._id },
    process.env.JWT_SECRET,
    { expiresIn: "1h" }
  );

  res.json({ token });
});

2️⃣ Protected route middleware

const auth = (req, res, next) => {
  const token = req.headers.authorization?.split(" ")[1];

  if (!token) {
    return res.status(401).json({
      message: "Unauthorized"
    });
  }

  const decoded = jwt.verify(token, process.env.JWT_SECRET);
  req.user = decoded;

  next();
};

3️⃣ Use it in routes

app.get("/profile", auth, (req, res) => {
  res.json({
    message: "Private profile",
    user: req.user
  });
});

=> Why JWT is powerful...... JWT enables:
- stateless authentication
- scalable APIs
- mobile + web integration
- role-based access

⚠️ Production tip
Never store sensitive data directly inside the token
Keep only identifiers + roles

# Day 8 takeaway

Authentication is about secure request identity across every API call🔐

Tomorrow — Refresh Tokens + Access Tokens ... how big apps keep users logged in :}


@devcap12
#30dayschallenge #nodejs #BackendDev