Nithin Shibu Mathew

Senior Software Engineer

[Nick Chapsas @nickchapsas]

So no .NET Conf from Microsoft this year because Microsoft doesn't want to support it. Interesting.

[Nick Chapsas @nickchapsas]

Context by @csharpfritz's latest livestream. Catch the full VOD here: https://t.co/8wz3UvL0Dy

[Anish Giri @anishgiri]

The Myth of “Love Learning”

People often ask me how to get better at chess. My answer is almost the opposite of what people expect.

You don’t have to love learning.

In fact, if you wait until you love the process, you’ll probably never become very good.

We romanticize improvement. We imagine great players waking up excited to study endgames, analyze losses, or memorize opening lines. Sometimes that’s true. Most of the time it isn’t.

Improvement is often boring.

The difference between an amateur and a professional isn’t that the professional enjoys every minute. It’s that they keep going when they don’t.

People say children are fearless learners. I’m not so sure.

Children quit things constantly. Piano. Swimming. Languages. Football. Chess. They usually continue only because someone else insists they do. Parents. Teachers. Coaches.

Discipline often comes before passion, not after.

The same is true for adults.

We tell people to “follow your curiosity.” That’s wonderful advice if curiosity happens to last. Usually it doesn’t.

Every meaningful skill has a point where curiosity runs out and routine takes over.

That’s where improvement actually begins.

Chess certainly did not always feel like play to me.

There were tournaments where the last thing I wanted to do after six hours of defending a miserable endgame was analyze another five hours.

There were openings I studied not because they fascinated me, but because my opponents forced me to.

There were positions I analyzed simply because they were objectively important.

Not because they were fun.

Because they needed to be done.

People often criticize schools for asking the wrong questions.

But there’s another side to that story.

If everyone only studied the questions they found interesting, most people would develop huge blind spots.

Sometimes someone else knows what you need to learn before you do.

Nobody is naturally curious about tax law before becoming an accountant. Or anatomy before becoming a surgeon. Or rook endings before losing enough of them.

External structure isn’t always the enemy of learning.

Often it’s the bridge that gets you to the point where genuine curiosity develops.

The biggest obstacle isn’t fear of looking stupid.

It’s our addiction to doing only what feels rewarding today.

Modern life gives us endless opportunities to switch the moment something becomes difficult.

A new opening.

A new productivity system.

A new app.

A new hobby.

Very few people simply keep doing the same useful thing for years.

That’s the superpower.

So when people ask how to improve at chess, I don’t tell them to fall in love with learning.

Love helps.

Curiosity helps.

Being willing to fail helps.

But none of those are reliable.

Build habits that survive the days when none of those feelings are there.

Because mastery isn’t built on motivation.

It’s built on showing up after motivation has left the room.

[Stefan Đokić | .NET @TheCodeMan__]

𝟭𝟬 years in .NET.
If I had to start again today, from zero, this is exactly what I would do.

𝟭. I would master debugging before mastering design patterns.
𝟮. I would learn how HTTP actually works.
𝟯. I would deeply understand async/await.
𝟰. I would learn how memory works in .NET (GC, allocations).
𝟱. I would build one ugly but working CRUD app.
𝟲. I would deploy something in the first 30 days.
𝟳. I would learn Git properly (rebase, squash, cherry-pick).
𝟴. I would read existing production code daily.
𝟵. I would study logging and observability early.
𝟭𝟬. I would learn how to write meaningful commit messages.
𝟭𝟭. I would focus on architecture after building real apps, not before.
𝟭𝟮. I would learn SQL seriously, not just EF Core.
𝟭𝟯. I would understand transactions and isolation levels.
𝟭𝟰. I would practice writing tests that actually fail.
𝟭𝟱. I would learn to read stack traces fluently.
𝟭𝟲. I would learn Docker basics in year one.
𝟭𝟳. I would understand dependency injection internally, not just use it.
𝟭𝟴. I would measure performance before optimizing anything.
𝟭𝟵. I would avoid microservices until I truly need them.
𝟮𝟬. I would build at least one API from scratch without templates.
𝟮𝟭. I would learn how authentication and authorization really work.
𝟮𝟮. I would understand what happens when production crashes.
𝟮𝟯. I would study real post-mortems of outages.
𝟮𝟰. I would learn how to review code properly.
𝟮𝟱. I would keep pull requests small.
𝟮𝟲. I would learn to communicate technical trade-offs clearly.
𝟮𝟳. I would avoid copying architectures from YouTube.
𝟮𝟴. I would understand threading before touching parallelism.
𝟮𝟵. I would learn to read documentation, not just tutorials.
𝟯𝟬. I would build side projects that solve real problems.
𝟯𝟭. I would learn CI/CD in year one.
𝟯𝟮. I would understand how APIs fail and design for failure.
𝟯𝟯. I would study security basics early (OWASP, input validation).
𝟯𝟰. I would seek feedback aggressively.
𝟯𝟱. I would focus on clarity over cleverness.

After 10 years, I don’t believe in “learn everything.”
I believe in mastering fundamentals deeply.

It will sound like an AI, but it's true:

Frameworks change.
Principles don’t.
—

Join 20,000+ engineers in the .NET Newsletter. You will learn .NET and Architecture every week directly from your email: https://t.co/gI46R2Kc0c

If you're starting today, focus on depth, not hype.

♻️ Repost if this helps someone.
➕ Follow for pragmatic .NET & Architecture insights.

[Raul Junco @RaulJuncoV]

35 practical thoughts on system design

Core Principles

1. Every system is a trade-off -> you never get speed, cost, and simplicity all at once.
2. Latency compounds -> every millisecond added across layers adds up to user pain.
3. Scalability ≠ performance -> one handles growth, the other handles speed.
4. Read vs. write paths -> scaling each requires completely different strategies.
5. Design for change, not perfection -> requirements will shift.

Databases & Storage

6. Indexes are levers -> high-selectivity columns are worth indexing, low ones often aren’t.
7. Replication helps reads, partitioning helps writes -> don’t confuse the two.
8. Dual writes are a lie -> without coordination, you will see drift.
9. Event stores > queues (sometimes) -> better traceability, worse simplicity.
10. Cache invalidation is still the hardest problem -> freshness vs. performance is the eternal fight.

Reliability & Consistency

11. Idempotency saves you -> retries without it will hurt.
12. Fail fast, fail loud -> silent failures sink systems.
13. Eventual consistency is a feature -> not a bug, but only if the business allows it.
14. Conflict resolution in active-active is business logic, not infra.
15. Durability isn’t free -> syncing across regions has cost and latency.

Architecture Patterns

16. Microservices are an org structure, not a tech goal.
17. Monolith first, modular second, microservices last -> don’t jump too early.
18. Choreography scales, orchestration simplifies -> pick based on team maturity.
19. Serverless buys you focus, costs you control.
20. Queues don’t remove work, they smooth it.

Observability & Operations

21. Tracing > logging -> logs tell you “what”, traces tell you “why”.
22. Metrics rot without ownership -> measure what someone actually uses.
23. Retries without backoff = DDoS on yourself.
24. Dead-letter queues aren’t optional -> every system has poison messages.
25. Levers > knobs -> design quick kill switches and controls to contain blast radius.

Performance & Cost

26. Optimize the hot path, not the cold path.
27. Most bottlenecks live in the database, not the code.
28. Horizontal scaling beats vertical scaling ->until coordination kills it.
29. Warm caches mask bad queries -> measure against cold starts too.
30. The cheapest resource is disk, the most expensive is time.

People & Process

31. The best architecture dies without documentation.
32. System design reviews aren’t about diagrams, they’re about trade-offs.
33. Small PRs are for speed, big PRs are for context -> balance both.
34. A senior engineer’s role in design is asking the uncomfortable “what if”.
35. No design survives first contact with production -> but good ones bend instead of break.

What else?

[Arpit Bhayani @arpit_bhayani]

Empathy is what separates great engineers from code monkeys.

Being non-empathetic is actually costing you opportunities and career growth. Let me elaborate...

Remember, your job is to solve a problem, not just write code. You are not a code monkey who just hammers the keyboard. You are on a journey to build something that millions use, and for that, you have to

- build a great product
- operate effectively at your workplace

By thinking deeply about user experience and product flow, you can design your system better, plan future features, and keep your code extensible. Moreover,

- you ask the right questions during discussions
- you think of edge cases that others might miss
- your code stays flexible in the right places
- you can push back on bad designs with better justifications

When you understand how people actually use software, you build flexible systems instead of rigid solutions that break with the first change request.

Too many engineers skip this because it feels like "extra work" - but it's the work that makes all the difference.

Beyond product thinking, if you are empathetic, you communicate better with peers, product managers, designers, and stakeholders. By being a great operator, you improve your reputation and build trust, leading to more impactful work.

The most impactful projects aren't given to the smartest engineer, but to the one who shows they care enough to deliver real value, every time.

[Ashwin 🇮🇳 @ashwinravi99]

After the penny drops.

Some wins feel special, and this one truly does from a POV “ this isn’t just a World Cup win, it’s a statement.

@surya_14kumar for the fearless energy you bring to the team is infectious.

@GautamGambhir for the grit and winning mindset you have managed to instil.

@IamSanjuSamson for staying calm, classy and always carrying the hopes of so many fans with grace.

When the pressure peaks, you somehow become even better. Simply priceless. @Jaspritbumrah93

Congratulations on bringing the T20 World Cup home. Moments like these will stay with us forever. 🇮🇳🏆

[Nithin Shibu Mathew @__nithin__]

@brankopetric00 mv

[Ashish Pratap Singh @ashishps_1]

If you want to get good at System Design in 2026, consider learning these 30 concepts:

1. Client-Server Architecture
2. IP Address
3. DNS
4. Proxy / Reverse Proxy
5. Latency
6. HTTP/HTTPS
7. APIs
8. Rest API
9. GraphQL
10. Databases
11. SQL vs NoSQL
12. Vertical Scaling
13. Horizontal Scaling
14. Load Balancers
15. Indexing
16. Replication
17. Sharding
18. Vertical Partitioning
19. Caching
20. Denormalization
21. CAP Theorem
22. Blob Storage
23. CDN
24. WebSockets
25. Webhooks
26. Microservices
27. Message Queues
28. Rate Limiting
29. API Gateways
30. Idempotency

♻️ Repost to help others in your network.

[Ujjwal Chadha @ujjwalscript]

I’ve been a developer for 10 years.

I’ve mastered languages. I’ve optimized databases. I’ve built systems that handle millions of requests.

But last week, a Junior dev outperformed me.

He didn’t know how to write a complex program. He couldn’t explain the difference between a proper monoloth and a microservice. He didn't even know how the code worked in some parts.

But he knew how to talk to the Agents.
He orchestrated three AI workers. One for the frontend. One for the backend logic. One for the unit tests.

In 4 hours, he pushed a feature that would have taken me 3 days.

I felt a cold shiver. "Is this it?" I thought. "Am I finally the legacy hardware?"

But then I looked at his PR. It was fast. It was functional. But it was… fragile.
It lacked architectural vision. It had security holes that only someone who has been "burned" would see. It was a house built on sand.

That’s when I realized the truth about 2026.

The "Senior" title isn't about how fast you type anymore. It's about how well you judge.

We are moving from being "builders" to being "architects." From "coders" to "composers."

If you’re a veteran feeling left behind by AI: Don’t compete on speed. Compete on wisdom.

The machine can write the notes. Only you can write the symphony.

[Mukesh Murugan @iammukeshm]

After mass layoffs, 2025 is now the year of upskilling.

I've spent 10+ years writing .NET code. Debugging at 2 AM. Refactoring nightmares. Learning what NOT to do the hard way.

Here are 20 lessons that took me years to learn:

1. Master fundamentals before frameworks
2. Clean code > clever code
3. Dependency Injection isn't optional
4. async/await has rules — learn them
5. Log what matters, not everything
6. EF Core is powerful but dangerous
7. CancellationTokens save resources
8. Dapper for performance-critical queries
9. REST has best practices — follow them
10. Global exception handling is non-negotiable
11. Write tests (I regret not doing this earlier)
12. Background services for long-running tasks
13. Never hardcode secrets
14. Caching is your best friend
15. Avoid reflection unless absolutely necessary
16. Polly for resilience
17. CI/CD for automated deployments
18. Keep up with .NET updates
19. Feature flags for safer releases
20. Never stop learning

Each one of these has a story behind it. A bug. A production incident. A lesson learned.

I wrote a detailed article covering all 20 with code examples, bad vs good patterns, and real-world context.

Read: https://t.co/4oWvGQZVCe

Which tip resonates with you the most? Drop a number below.

[Neo Kim @systemdesignone]

If you're serious about SYSTEM DESIGN (in 2026), learn these 12 case studies:

1. How Google Docs Works
↳ https://t.co/W57IkAjXpT

2. How Spotify Works
↳ https://t.co/BxrH3oHIFS

3. How Reddit Works
↳ https://t.co/o6Pw2hhj3T

4. How Bluesky Works
↳ https://t.co/2rLYlRlky0

5. How ChatGPT Works
↳ https://t.co/5lCKxq2g4N

6. How Kafka Works
↳ https://t.co/8rOy9KgCMo

7. How Slack Works
↳ https://t.co/eIo29uOQOJ

8. How Meta Handles 11.5M Serverless Function Calls per Second:
↳ https://t.co/NSt6jovxu5

9. How Uber Finds Nearby Drivers
↳ https://t.co/kJ2t8dtmch

10. How Twitter Timeline Works
↳ https://t.co/pF2RYmPaIG

11. How YouTube Was Able to Support 2.49 Billion Users With MySQL
↳ https://t.co/4VDJ5cs6fL

12 How to Scale an App to 10 Million Users on AWS
↳ https://t.co/RozCGli0r8

(What else should make this list?)

——

👋 PS - Want my System Design Playbook for free?

Join my newsletter with 200K+ software engineers:

→ https://t.co/ByOFTtOihX

———

💾 Save this for later, and RT it to help others master system design.

👤 Follow @systemdesignone + turn on notifications.

[Striver | Building takeUforward @striver_79]

Coding was always the easiest part of the job, and AI has taken over much of it now.

The tough part still stays with the human mind:

- Designing the system end-to-end (tradeoffs, constraints, scale)
- Breaking vague requirements into clear specs
- Choosing the right abstractions, data models, and boundaries
- Thinking through edge cases before users find them
- Making it reliable: failures, retries, idempotency, fallbacks
- Security + privacy by default
- Observability: logs, metrics, tracing, alerts, SLOs
- Performance + cost: what matters at P95/P99, what’s waste
- End: “it works” isn’t the finish line

Engineers build systems. You may have an argument, if you write a detailed prompt covering all of it, AI will be able to do it. As I said, coding is the easier part of the job once you know what you up-to.

[Branko @brankopetric00]

Job posting:
"Required: CKA, AWS Solutions Architect, Terraform Associate"

What you actually need:
- Someone who can debug why the app is slow
- Someone who shows up at 2 AM when things break
- Someone who writes runbooks
- Someone who doesn't panic

Certifications can't measure:
- Problem-solving under pressure
- Communication during incidents
- Ability to learn new systems
- Not being an asshole on-call

You're filtering out the people you actually need.

[Branko @brankopetric00]

Our S3 bill was $4K/month. 92% was for data we deleted.

The situation:
- S3 bucket storing user uploads
- Implemented delete feature 2 years ago
- Users could delete their files
- Application removed records from database
- Files stayed in S3 forever

The problem:
- Delete operation removed DB records only
- S3 objects never actually deleted
- 47TB of "deleted" files
- Still paying for storage
- Versioning enabled making it worse

The discovery process:
- S3 inventory report showed massive discrepancy
- Cross-referenced with database
- Only 3.8TB of files were actually active
- 43.2TB were supposed to be deleted

The fix:
- Wrote script to identify orphaned files
- Compared S3 keys with database
- Deleted 43TB of orphaned objects
- Implemented S3 lifecycle policy
- Added proper deletion in application code
- Removed versioning (we had backups)

Cost before: $4K/month
Cost after: $870/month
Total wasted over 1 years: ~ $38K (including new monthly charge)

[Branko @brankopetric00]

We split one massive Lambda into 17 smaller functions.

The original problem:
- Single Lambda function doing everything
- 2800 lines of Python
- 15-minute timeout limit
- Cold starts taking 8 seconds
- Deployment meant testing everything
- One bug broke all functionality

The new architecture:
- Event-driven with SQS queues
- Each Lambda does one thing
- Average function size: 120 lines
- Cold starts down to 400ms
- Independent deployments
- Failures are isolated

What we learned:
- Initial development was slower
- Debugging distributed systems is harder
- But production stability improved 10x
- Deployment velocity increased
- Team could work in parallel

AWS costs went DOWN by around 25% because of better resource utilization.

Monoliths are easy to build but hard to maintain. Distributed systems are hard to build but easier to maintain.

[Sachin Pandey @iamsachin_47]

One thing I’ve followed over the years — never talk about something before it happens.

When I was interviewing, only my family knew and no one else. Even after getting the offer, just a few (<5) friends knew I was switching.

I’ve always believed that silence protects progress — not everything needs to be announced. The world doesn’t always need to know your next move.

If you truly want to grow, protect your plans. Move quietly, let your results make the noise. All the best.

[SolidBase @BaseSolid85759]

Mastering SOLID Principles in C# — [1/5] Single Responsibility Principle (SRP)

Most developers know SOLID principles, but few truly apply them.

Let’s break down the Single Responsibility Principle (SRP) in simple terms — with examples you can use even in interviews 👇

[Rockstar Games @RockstarGames]

Hi everyone,

Grand Theft Auto VI will now release on Thursday, November 19, 2026.

We are sorry for adding additional time to what we realize has been a long wait, but these extra months will allow us to finish the game with the level of polish you have come to expect and deserve.

[Branko @brankopetric00]

Breakdown of AWS outage in simple words

1. Sunday night, a DNS problem hit AWS - DynamoDB endpoint lost

2. This meant services couldn't find DynamoDB (a database that stores tons of data).

3. AWS fixed the DNS issue in about 3 hours.

4. But then EC2 (the system that creates virtual servers) broke because it needs DynamoDB to work.

5. Then the system that checks if network load balancers are healthy also failed.

6. This crashed Lambda, CloudWatch, SQS, and 75+ other services - everything that needed network connectivity.

7. This created a chain reaction - servers couldn't talk to each other, new servers couldn't start, everything got stuck

8. AWS had to intentionally slow down EC2 launches and Lambda functions to prevent total collapse.

9. Recovery took 15+ hours as they fixed each broken service while clearing massive backlogs of stuck requests.

This outage impacted: Snapchat, Roblox, Fortnite, McDonald's app, Ring doorbells, banks, and 1,000+ more websites.

This all happened in one AWS region (us-east-1).

This is why multi-region architecture isn't optional anymore.