Daniel Nweze

Frontend Engineer | React • TypeScript | AltSchool Africa

[Daniel Nweze @iamflashdaniel]

🚀 From almost giving up to graduating.

AltSchool Africa Software Engineering graduate.

85% | 90% | 90% → 88% → 97%

Grateful to God, family, Ayoba & @amaraonyeji.

Open to global opportunities 💻

#AltGrads26 #TrainedByAltSchool #Baraka25

[Daniel Nweze @iamflashdaniel]

@sironyeka Hey

[Daniel Nweze @iamflashdaniel]

@Techk_e4ma Active

[Daniel Nweze @iamflashdaniel]

Just earned my Frontend Engineering Diploma from AltSchool Africa 🎓

Stronger in building, thinking, and solving real-world problems.

This is only the beginning 🚀

#Frontend #100DaysOfCode #AltSchoolAfrica #BuildInPublic

[Daniel Nweze @iamflashdaniel]

@amaraonyeji Thank you

[Daniel Nweze @iamflashdaniel]

🚀 From almost giving up to graduating.

AltSchool Africa Software Engineering graduate.

85% | 90% | 90% → 88% → 97%

Grateful to God, family, Ayoba & @amaraonyeji.

Open to global opportunities 💻

#AltGrads26 #TrainedByAltSchool #Baraka25

[Daniel Nweze @iamflashdaniel]

@symbusi @amaraonyeji Thank you

[Daniel Nweze @iamflashdaniel]

@Arixold Hey

[Daniel Nweze @iamflashdaniel]

Third semester results from @AltSchoolAfrica are finally in! 🎓
​Honestly, it wasn't an easy road. There were so many hurdles that almost made me stop, but I’m standing tall today. So proud of my progress and grateful to God for the strength to finish strong. 🚀✨

[Daniel Nweze @iamflashdaniel]

@Raynerdtech I can't remember the last time I did that. Always on sleep mode. Even now it's on sleep mode.

[Daniel Nweze @iamflashdaniel]

It’s funny how things that once felt hard, confusing, and impossible now feel so easy, like I was born knowing them.
What used to stress me out now flows naturally.

Consistency really turns confusion into clarity. 🚀

[G.Jonathan @beardedtech_guy]

𝗱𝗮𝘆 𝟭𝟲 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign

As systems grow and data spreads across multiple machines, a new problem appears: you can no longer assume everything is always in sync.

This is where the CAP Theorem comes in.

The CAP Theorem states that in a distributed system, you can only fully guarantee two out of three properties:
Consistency, Availability, and Partition Tolerance.

𝗖𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝘆 means every request sees the same data at the same time.
𝗔𝘃𝗮𝗶𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆 means every request gets a response, even during failures.
𝗣𝗮𝗿𝘁𝗶𝘁𝗶𝗼𝗻 𝘁𝗼𝗹𝗲𝗿𝗮𝗻𝗰𝗲 means the system continues working even when parts of the network can’t communicate.

In real systems, network failures are unavoidable. Once a partition happens, you must choose between staying consistent or staying available.

Now think of a restaurant 🍽️

Imagine a restaurant with multiple branches sharing the same menu and inventory system. If the network goes down between branches, the restaurant must decide: stop taking orders until everything is synced, or keep serving customers even if inventory data may be outdated.

That decision is CAP in action.

CAP is not about what you prefer.
It’s about what you sacrifice when things go wrong.

read the full thing here (https://t.co/b11HdwtQgG)

God bless @TosinOlugbenga Picked up system deisgn coz of him.

[G.Jonathan @beardedtech_guy]

𝗱𝗮𝘆 𝟭𝟱 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign

At a basic level, SQL and NoSQL are often described as “tables vs documents” or “structured vs flexible.”
But there's more to it

SQL databases are relational systems built around strong consistency, structured schemas, and transactional guarantees. They prioritize correctness and relationships between data.

NoSQL databases are distributed-first systems designed around horizontal scaling, flexible data models, and availability under load. They prioritize performance and scale, sometimes at the cost of strict consistency.

The real difference shows up when systems grow.

SQL systems enforce relationships, constraints, and transactions across data. This makes them ideal when accuracy matters deeply, but harder to scale across many machines.

NoSQL systems relax some of these guarantees to scale easily. They are designed to distribute data across nodes and continue working even during partial failures.

Now think of a restaurant 🍽️

A fine-dining restaurant has strict recipes, precise measurements, and carefully coordinated chefs. Every dish must be correct. That’s SQL.

A fast-food chain focuses on speed, volume, and consistency across locations. Recipes are simpler, and flexibility allows the system to scale globally. That’s NoSQL.

Neither is better. They solve different problems.

System design is about choosing the right tradeoffs.

[G.Jonathan @beardedtech_guy]

𝗱𝗮𝘆 𝟭𝟰 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign

Before scaling, caching, or load balancing can truly work, one thing must be clear: 𝘄𝗵𝗲𝗿𝗲 𝘆𝗼𝘂𝗿 𝗱𝗮𝘁𝗮 𝗹𝗶𝘃𝗲𝘀 𝗮𝗻𝗱 𝗵𝗼𝘄 𝗶𝘁’𝘀 𝗮𝗰𝗰𝗲𝘀𝘀𝗲𝗱.

At its core, a database is the system’s long-term memory. It is responsible for storing data reliably, retrieving it efficiently, and ensuring it remains correct over time. Every request eventually touches the database, either directly or indirectly.

Databases are designed to answer three fundamental questions:
Can the data be stored safely?
Can it be retrieved quickly?
Can it remain consistent as the system grows?

When databases are poorly designed or misunderstood, systems slow down, errors increase, and scaling becomes painful. Many performance issues blamed on “traffic” are actually data access problems.

Now think of a restaurant 🍽️

The storage room is where all raw ingredients are kept. It must be organized, reliable, and accessible at all times. If ingredients are misplaced, spoiled, or hard to find, the kitchen suffers no matter how skilled the chefs are.

The kitchen doesn’t question whether the storage room exists. It assumes it works. T𝗵𝗮𝘁’𝘀 𝗵𝗼𝘄 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝘁𝗿𝗲𝗮𝘁 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀. 𝗪𝗵𝗲𝗻 𝘁𝗵𝗲 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝘀𝘁𝗿𝘂𝗴𝗴𝗹𝗲𝘀, 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗮𝗯𝗼𝘃𝗲 𝗶𝘁 𝗳𝗲𝗲𝗹𝘀 𝗯𝗿𝗼𝗸𝗲𝗻.

𝗦𝘁𝗿𝗼𝗻𝗴 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝘀𝘁𝗮𝗿𝘁 𝘄𝗶𝘁𝗵 𝘀𝘁𝗿𝗼𝗻𝗴 𝗱𝗮𝘁𝗮 𝗳𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻𝘀.

Missed day 13? here you go [https://t.co/dhueBqEHrE]

Tomorrow, we’ll talk about types of databases and when to use each.

[G.Jonathan @beardedtech_guy]

𝗱𝗮𝘆 𝟭𝟯 𝗼𝗳 𝟭𝟬𝟬
#100DaysOfSystemDesign

Caching makes systems faster, but caching alone is not enough.
Once data is cached, the real problem becomes how long that data should be trusted.

When an application serves data from cache, it is serving a snapshot in time. If the original data changes and the cache is not updated, users begin to see stale information. This is why caching always comes with two important concepts: expiration and invalidation.

𝗖𝗮𝗰𝗵𝗲 𝗲𝘅𝗽𝗶𝗿𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝘁𝗶𝗺𝗲 𝗯𝗮𝘀𝗲𝗱. Data is stored for a defined period and automatically removed after that time passes.

This approach is simple and works well when data does not change often or when slight delays in freshness are acceptable.

𝗖𝗮𝗰𝗵𝗲 𝗶𝗻𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝗲𝘃𝗲𝗻𝘁 𝗯𝗮𝘀𝗲𝗱. When the source data changes, the cache is immediately cleared or updated.

This is necessary for systems where correctness matters, such as payments, sessions, inventory, or user profiles.

𝗡𝗼𝘄 𝘁𝗵𝗶𝗻𝗸 𝗼𝗳 𝗮 𝗿𝗲𝘀𝘁𝗮𝘂𝗿𝗮𝗻𝘁 🍽️

Some items in the kitchen are prepared once and trusted for the entire day. They are refreshed on a schedule, not every time someone orders. That’s cache expiration.

But if an ingredient suddenly goes bad or runs out, the kitchen stops using it immediately. Waiting until closing time would cause serious problems. That’s cache invalidation.

Fast systems are easy to build.
Correct and fast systems are designed.

Missed day 12? here you go [https://t.co/Du9ZU9GZ0b]

Inspired by @TosinOlugbenga and my bro @gozkybrain4u

[G.Jonathan @beardedtech_guy]

Day 12: Where Caches Live
#𝟭𝟬𝟬𝗗𝗮𝘆𝘀𝗢𝗳𝗦𝘆𝘀𝘁𝗲𝗺𝗗𝗲𝘀𝗶𝗴𝗻

Caching isn’t just about what you cache.
It’s equally about where the cached data lives.

Different cache locations exist because systems optimize for different things:
latency, freshness, scalability, and control.

Let’s break it down 👇

Some caches live on the client.
Browsers, mobile apps, and devices store data locally to avoid repeated requests.
This gives near-instant responses but makes consistency difficult.

Other caches live inside the application layer.
These are in-memory stores close to the business logic.
They’re fast, controllable, and commonly used for frequently accessed data.

Then there are edge or network caches.
These sit closer to users geographically and reduce global latency while shielding backend services from load.

𝗧𝗵𝗲 𝗰𝗹𝗼𝘀𝗲𝗿 𝗮 𝗰𝗮𝗰𝗵𝗲 𝗶𝘀 𝘁𝗼 𝘁𝗵𝗲 𝘂𝘀𝗲𝗿, 𝘁𝗵𝗲 𝗳𝗮𝘀𝘁𝗲𝗿 𝗶𝘁 𝗶𝘀.
The farther it is, the easier it is to manage consistently.

Great systems don’t rely on one cache layer.
They intentionally combine multiple layers.

Missed day 11 ? here you go (https://t.co/YB8t6GIpfG)

Tomorrow: cache expiration and invalidation where things get tricky.

[G.Jonathan @beardedtech_guy]

Day 11: Caching Basics
#100DaysOfSystemDesign
As systems scale, not every request should hit the database.

Some data is requested repeatedly, and recomputing or refetching it every time wastes time and resources.

This is where caching comes in.

Caching is the practice of storing frequently accessed data closer to where it’s needed, so future requests can be served faster.

Think of a restaurant.

Instead of cooking every dish from scratch each time, the kitchen preps popular ingredients in advance.

When an order comes in, the meal is ready much faster.

Caching reduces response time, lowers load on databases, and improves system throughput.

But caching comes with trade offs.
Data can become stale, and deciding what to cache and when to refresh it matters.

Caching is not about speed alone.
It’s about using resources intelligently.
Tomorrow, we’ll talk about where caches live and common caching patterns.

[DevCareer Africa @dev_careers]

“I didn’t start tech on time.”
“My mates are already ahead of me.”
“I feel like I can’t catch up.”

We hear this all the time, and if this sounds like you, take a moment to breathe.
You are not behind.

There is no fixed timeline in tech. Everyone’s journey is different, and comparison only takes away your confidence. What truly matters is that you started, you are learning, and you are showing up for yourself.

Trust yourself enough to keep going.
Trust the process.
This is your story, and only you get to write it. Do not compare your chapter one to someone else’s chapter ten.

Your time is now. 💙

#DevCareer #TechCommunity #TechCareer #TechInAfrica #KeepGoing

[G.Jonathan @beardedtech_guy]

𝗗𝗮𝘆 𝟭𝟬: 𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗶𝗻𝗴 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝗶𝗲𝘀
#100DaysOfSystemDesign

Yesterday, we i𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝗱 𝗹𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗶𝗻𝗴 and why it’s essential once systems scale horizontally.

Today, let’s talk about how load balancers decide where traffic goes.

Load balancing strategies are the rules used to distribute incoming requests across multiple servers. The goal is to keep the system fast, fair, and resilient under load.

There are three commonly used strategies.

𝗥𝗼𝘂𝗻𝗱 𝗥𝗼𝗯𝗶𝗻 sends requests to servers one after the other, assuming all servers are equally capable.

𝗟𝗲𝗮𝘀𝘁 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻𝘀 routes traffic to the server currently handling the fewest active requests.

𝗛𝗮𝘀𝗵 𝗕𝗮𝘀𝗲𝗱 𝗥𝗼𝘂𝘁𝗶𝗻𝗴 consistently sends similar requests to the same server, often based on user or request attributes.

Now, think of a restaurant.

𝗥𝗼𝘂𝗻𝗱 𝗥𝗼𝗯𝗶𝗻 𝗶𝘀 𝗹𝗶𝗸𝗲 𝘀𝗲𝗮𝘁𝗶𝗻𝗴 𝗴𝘂𝗲𝘀𝘁𝘀 𝗲𝘃𝗲𝗻𝗹𝘆 𝗮𝗰𝗿𝗼𝘀𝘀 𝗮𝗹𝗹 𝘄𝗮𝗶𝘁𝗲𝗿𝘀, 𝗼𝗻𝗲 𝗯𝘆 𝗼𝗻𝗲, 𝘄𝗵𝗲𝗻 𝗲𝘃𝗲𝗿𝘆𝗼𝗻𝗲 𝗶𝘀 𝗲𝗾𝘂𝗮𝗹𝗹𝘆 𝗳𝗿𝗲𝗲.

𝗟𝗲𝗮𝘀𝘁 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻𝘀 𝗶𝘀 𝗹𝗶𝗸𝗲 𝘀𝗲𝗻𝗱𝗶𝗻𝗴 𝗴𝘂𝗲𝘀𝘁𝘀 𝘁𝗼 𝘁𝗵𝗲 𝘄𝗮𝗶𝘁𝗲𝗿 𝘄𝗵𝗼 𝗶𝘀 𝗰𝘂𝗿𝗿𝗲𝗻𝘁𝗹𝘆 𝗹𝗲𝗮𝘀𝘁 𝗯𝘂𝘀𝘆 𝗱𝘂𝗿𝗶𝗻𝗴 𝗽𝗲𝗮𝗸 𝗵𝗼𝘂𝗿𝘀.

𝗛𝗮𝘀𝗵 𝗯𝗮𝘀𝗲𝗱 𝗿𝗼𝘂𝘁𝗶𝗻𝗴 𝗶𝘀 𝗹𝗶𝗸𝗲 𝗮𝘀𝘀𝗶𝗴𝗻𝗶𝗻𝗴 𝗿𝗲𝗴𝘂𝗹𝗮𝗿 𝗰𝘂𝘀𝘁𝗼𝗺𝗲𝗿𝘀 𝘁𝗼 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘄𝗮𝗶𝘁𝗲𝗿 𝗲𝘃𝗲𝗿𝘆 𝘁𝗶𝗺𝗲 𝗯𝗲𝗰𝗮𝘂𝘀𝗲 𝘁𝗵𝗮𝘁 𝘄𝗮𝗶𝘁𝗲𝗿 𝗸𝗻𝗼𝘄𝘀 𝘁𝗵𝗲𝗶𝗿 𝗽𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲𝘀.

Each strategy solves a different problem.
Choosing the wrong one can create bottlenecks even with many servers.

Tomorrow, we’ll look at where load balancers sit in real system architectures.

[G.Jonathan @beardedtech_guy]

Day 8 #100DaysOfSystemDesign Recap (Lesson 1 to 7)

The last 7 days have been about building a solid mental model for system design, starting from fundamentals and gradually layering complexity.

𝗗𝗮𝘆 𝟭: 𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝘁𝗼 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻
What system design really means, how to think in systems, and why it goes beyond diagrams and tools.
https://t.co/NPe8n2AtpJ

𝗗𝗮𝘆 𝟮: 𝗪𝗵𝘆 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 𝗠𝗮𝘁𝘁𝗲𝗿𝘀
A bird’s eye view of why scalable, reliable systems are intentional, not accidental.
https://t.co/UZAFgfmZYV

𝗗𝗮𝘆 𝟯: 𝗧𝘆𝗽𝗲𝘀 𝗼𝗳 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 (𝗛𝗟𝗗 & 𝗟𝗟𝗗)
Understanding the difference between high level architecture and low level implementation decisions.
https://t.co/yRGW8gjazD

𝗗𝗮𝘆 𝟰: 𝗦𝗰𝗮𝗹𝗶𝗻𝗴 𝗕𝗮𝘀𝗶𝗰𝘀
What scaling really means, when systems break, and why foresight matters before growth hits.
https://t.co/U134eUoSoJ

𝗗𝗮𝘆 𝟱: 𝗩𝗲𝗿𝘁𝗶𝗰𝗮𝗹 𝗦𝗰𝗮𝗹𝗶𝗻𝗴
Making a single machine stronger, how CPU and RAM affect performance, and why this approach has limits.
https://t.co/LL6IdjsUGx

𝗗𝗮𝘆 𝟲: 𝗛𝗼𝗿𝗶𝘇𝗼𝗻𝘁𝗮𝗹 𝗦𝗰𝗮𝗹𝗶𝗻𝗴
Adding more machines, distributing load, and why this changes how systems are designed.
https://t.co/69AAmMkByc

𝗗𝗮𝘆 𝟳: 𝗦𝘁𝗮𝘁𝗲𝗹𝗲𝘀𝘀 𝘃𝘀 𝗦𝘁𝗮𝘁𝗲𝗳𝘂𝗹 𝗦𝘆𝘀𝘁𝗲𝗺𝘀
How systems manage user data, why stateless systems scale better, and where state still matters.
https://t.co/nNePxDGAUx

Week 1 focused on foundations.
Week 2 goes deeper into real world trade offs.

Thanks to everyone engaging so far, real mvps.

Inspired by my chief director @TosinOlugbenga and my bro @gozkybrain4u