🚀 Free Live Session Recording – Build a Scalable API Gateway in Go (from Scratch!) This is the recording of our Week 1 session from the 5-Week System Design Challenge for Golang Developers. In this 1-hour hands-on session, we covered: 1️⃣ System Design Blueprint – Designing...
🚀 Free Live Session Recording – Build a Scalable API Gateway in Go (from Scratch!)
This is the recording of our Week 1 session from the 5-Week System Design Challenge for Golang Developers.
In this 1-hour hands-on session, we covered:
1️⃣ System Design Blueprint – Designing an API Gateway that can handle 100–1000 RPS
2️⃣ Gateway Skeleton – Building a minimal API Gateway in Go
3️⃣ Configurable Rate Limiter – Implementing Token Bucket with configurable RPS and burst size
💡 Perfect for beginner and intermediate Go developers looking to level up their backend and system design skills.
👇 Join the community for upcoming live sessions:
🔗 Discord: [Insert Discord Link]
🔗 LinkedIn: https://www.linkedin.com/in/architagarwal984/
🔗 Newsletter: https://www.linkedin.com/newsletters/the-weekly-golang-journal-7261403856079597568/
🔗 YouTube: https://www.youtube.com/@TheExceptionHandler
#golang #backenddevelopment #systemdesign #apigateway #ratelimiting #learningcommunity #godevelopers #microservices
🚀 Struggling with Golang interview questions on concurrency? You’re not alone — Goroutines, Channels, Context, and Mutex often trip up even experienced Go developers in interviews. That’s why Archit Agarwal (The Exception Handler) and Divesh Kumar (DiTechVerse) have teamed up...
🚀 Struggling with Golang interview questions on concurrency?
You’re not alone — Goroutines, Channels, Context, and Mutex often trip up even experienced Go developers in interviews.
That’s why Archit Agarwal (The Exception Handler) and Divesh Kumar (DiTechVerse) have teamed up to bring you a Live Golang Concurrency Mock Interview Webinar Series 🎯.
💡 What you’ll learn (in mock interview style):
✅ Session 1: Goroutines, concurrency vs parallelism, deadlocks, GMP Scheduler
✅ Session 2: Channels, select statement, stream merging, graceful shutdowns
✅ Session 3: Context with deadlines, retries, exponential backoff (production-ready code)
✅ Session 4: Mutex & Sync — solving race conditions and ensuring thread safety
✅ Session 5: Real-world concurrency patterns for speed & scalability
✅ Session 6: Bonus session with tricky interview Q&A + live audience questions
🔥 Why join?
Practice real interview-style questions (not just theory)
Learn how to steer the interview in your favor
Build confidence with concurrency fundamentals & advanced patterns
Get tips directly from engineers who’ve cracked backend interviews
📌 Registration Links + Discount Codes
Packages:
🎯 Ace Golang Concurrency for Your Next Interview → Register | https://topmate.io/archit_agarwal/167... | ₹3,499 | Code: GOFIRST10
🎯 Golang Concurrency Interview Webinar (Session 2-6) → Register | https://topmate.io/archit_agarwal/168... | ₹2,999 | Code: GoConcurrency10
🎯 Golang Concurrency Interview Webinar (Session 3-6) → Register | https://topmate.io/archit_agarwal/168... | ₹2,499 | Code: GoConcurrency10
🎯 Golang Concurrency Interview Webinar (Session 4-6) → Register | https://topmate.io/archit_agarwal/168... | ₹1,999 | Code: GoConcurrency10
🎯 Golang Concurrency Interview Webinar (Session 5-6) → Register | https://topmate.io/archit_agarwal/168... | ₹1,499 | Code: GoConcurrency10
Individual Sessions (₹799 each):
🟢 Session 1: Kickstarting Concurrency with Goroutines → 23rd Aug 2025 | Register | https://topmate.io/archit_agarwal/167... | Code: GOROUTINE10
🟢 Session 2: Channels & Select: The Dynamic Duo → 24th Aug 2025 | Register | https://topmate.io/archit_agarwal/167... | Code: GOCHANNEL10
🟢 Session 3: Go Context: The Art of Cancellation & Deadlines → 30th Aug 2025 | Register | https://topmate.io/archit_agarwal/167... | Code: GOROUTINE10
🟢 Session 4: Sync Like a Pro: Mutex, Channels & More → 31st Aug 2025 | Register | https://topmate.io/archit_agarwal/167... | Code: GOROUTINE10
🟢 Session 5: Real-World Concurrency Patterns for Go Interviews → 6th Sept 2025 | Register | https://topmate.io/archit_agarwal/167... | Code: GOROUTINE10
🟢 Session 6: Bonus Round: Your Concurrency Questions Answered → 6th Sept 2025 | Register | https://topmate.io/archit_agarwal/167... | Code: GOROUTINE10
(Note: These are paid webinars hosted on Topmate.)
💰 Pricing Options:
👉 ₹799 for any single session
👉 Discounted packages available (2, 3, or full 6 sessions)
👉 First 10 candidates get 10% off with the codes above
📌 Book your spot now via Topmate (links above)
Don’t wait for the interview to be your practice ground — train before you face it.
👉 Like, share & subscribe for more Golang interview prep from Archit & Divesh.
📺 General Guidance Video
🎥 Why GoLang is the Future of Backend | • Why GoLang is the Future of Backend | Arch...
Your no-BS guide to thriving as a backend dev in 2025 and beyond — GoLang, DevOps, SQL, architecture patterns, and career tips.
📚 Additional Learning Resources
Concurrency Fundamentals in Go
Goroutines in Golang | • Goroutines in Golang | Golang Concurrency ...
Golang Channels Tutorial | • Golang Channels Tutorial | Go
REST API Development in Go
Build A Web Server With Golang In 30 Mins | • Build A Web Server With Golang In 30 Mins ...
Building Microservices with Go | • Building Microservices with Go
Rest API in Golang using Gin Gonic | • Rest API in Golang using Gin Gonic
Golang Coding Interview Series | • Golang Coding Interview Series
#golang
#webserver
#whyGolang
#coding
#goprogramming
#backenddevelopment
#interview
#interviewquestions
#restapi
#htmltemplate
#goroutines
#golangproject
#golangtutorial
#codinginterview
#techjobs
#like
#subscribe
We’re going live to tackle a core topic in backend engineering: serialization. This session is based on Chapter 4: "Serialization" from the book Microservices with Go by Alexander Shuiskov. What we’ll cover: Why serialization matters in distributed systems JSON, XML, YAML →...
We’re going live to tackle a core topic in backend engineering: serialization.
This session is based on Chapter 4: "Serialization" from the book Microservices with Go by Alexander Shuiskov.
What we’ll cover:
Why serialization matters in distributed systems
JSON, XML, YAML → pros, cons, and where they shine
Apache Thrift & Avro → what makes them different
Protocol Buffers (Protobuf): how to implement them in Go
Live performance comparison: Protobuf vs JSON, XML, YAML
🎙 Part of: Backend Book Club
📅 When: [Tomorrow’s date], 12 Noon IST
📍 Where: The Exception Handler YouTube Channel
Bring your coffee ☕ and join us for a practical, interactive session.
Going live this Sunday at 12 PM IST! In this session, we're diving deep into Chapter 3: Service Discovery from the book Microservices with Go by Alexander Shuiskov — and trust me, this chapter hits differently when you've seen real-world service outages 👀. Here’s what we’ll...
Going live this Sunday at 12 PM IST!
In this session, we're diving deep into Chapter 3: Service Discovery from the book Microservices with Go by Alexander Shuiskov — and trust me, this chapter hits differently when you've seen real-world service outages 👀.
Here’s what we’ll break down together:
🔍 Why hardcoding service addresses is a career-limiting move
📡 What a Service Registry actually does (and what it shouldn’t)
🧭 Client-side vs Server-side service discovery explained with fun analogies
⚖️ Load balancing, health checks, and service reliability decoded
🔧 Real-world tooling: Consul, Kubernetes, etcd, and Zookeeper
🚨 And a sneak peek into how our Inventory App is being wired for this
This isn’t just a book club — it’s backend therapy.
Bring your doubts, your chai, and your inner backend engineer.
🔗 Subscribe to the channel: @TheExceptionHandler
📚 Book: Microservices with Go (by Packt Publishing)
🧠 Level: Beginner-friendly but with enough spice for experienced devs
Let’s make Sundays productive — and fun.
See you live!
🔥 Welcome to Episode 1 of the Backend Book Club! 🔥 In this series, we’ll go beyond blog posts and tutorials to dive deep into **real backend engineering** — one chapter, one design decision at a time. 📘 This week, we're reading: *Microservices with Go* by Alexander Shuiskov...
🔥 Welcome to Episode 1 of the Backend Book Club! 🔥
In this series, we’ll go beyond blog posts and tutorials to dive deep into **real backend engineering** — one chapter, one design decision at a time.
📘 This week, we're reading: *Microservices with Go* by Alexander Shuiskov
(You don’t need to read the book to join — just bring your backend brain! 🧠)
👨🏫 In this first session, we’ll cover:
- When monoliths actually make more sense
- When to go for microservices (and when you’re just overengineering 😅)
- A real-world case study: Designing an inventory system
- Clean backend structure and idiomatic practices
- Go-specific examples, but ideas apply to **any language**
📅 **Live Every Sunday at 12PM IST**
🎙️ Hosted by Archit — Backend Engineer, Go Enthusiast & the guy who panics less these days 😄
Let’s read, learn, debate, and level up — together.
👇 Drop your questions in the chat and join the conversation!
🔔 Don’t forget to subscribe so you don’t miss the next chapter.
#BackendBookClub #Microservices #SoftwareArchitecture #GoLang #MonolithVsMicroservices
Ever wondered what really happens behind that "429 Too Many Requests" error? In this video, I’ll walk you through the 5 most popular rate limiter algorithms, but not just with diagrams or code dumps — we’re talking real-world analogies, use cases, and practical advice that...
Ever wondered what really happens behind that "429 Too Many Requests" error?
In this video, I’ll walk you through the 5 most popular rate limiter algorithms, but not just with diagrams or code dumps — we’re talking real-world analogies, use cases, and practical advice that sticks.
From:
🪣 Token Bucket – burst-friendly, like prepaid internet
🫗 Leaky Bucket – calm and consistent like a Zen monk
⏳ Fixed Window – your neighborhood bouncer with a clock
📜 Sliding Window Log – the timestamp hoarder
🧠 Sliding Window Counter – smart and balanced
You’ll learn:
✅ How each algorithm works
✅ Which one to use when
✅ Their pros, cons, and production tradeoffs
✅ How they apply to real-world APIs and distributed systems
👨💻 Want to dive deeper or need working Go code?
📝 Read the full article with visuals and detailed examples:
👉 Medium: https://medium.com/@architagr/youre-probably-using-the-wrong-rate-limiter-here-s-how-to-fix-that-b3514f7e7256
👉 LinkedIn: https://www.linkedin.com/pulse/youre-probably-using-wrong-rate-limiter-heres-how-fixthat-agarwal-kwjpc/?trackingId=MHLo1ZvRRAKHLxfnbREoUQ%3D%3D
📦 Code Repo:
👉 GitHub: https://github.com/architagr/The-Weekly-Golang-Journal/tree/main/rate_limiter
🔗 Chapters:
00:00 Why Rate Limiting?
01:43 Types of Rate Limiter.
02:59 Token Bucket Rate Limiter
05:33 Leaky Bucket Rate Limiter
09:49 Fixed Window Counter Rate Limiter
12:49 Sliding Window Log Rate Limiter
16:35 Sliding Window Counter
17:53 Which One Should You Use?
18:52 Wrap-Up
📺 Subscribe for more backend engineering, Golang content, and system design breakdowns:
@TheExceptionHandler
Consistent Hashing is the secret sauce behind scalable systems like Redis, Memcached, and Cassandra — and today, you're going to implement it in Golang, step by step. 🔧 In this video, we’ll build a fully working distributed cache that: ✅ Uses a custom consistent hash ring ✅...
Consistent Hashing is the secret sauce behind scalable systems like Redis, Memcached, and Cassandra — and today, you're going to implement it in Golang, step by step.
🔧 In this video, we’ll build a fully working distributed cache that:
✅ Uses a custom consistent hash ring
✅ Handles dynamic node addition and removal
✅ Supports virtual nodes for better distribution
✅ Implements data redundancy across nodes
✅ Can tolerate node failures without breaking your app
This is not just a theory video. We’re building everything from scratch using Go — no third-party libraries, no magic.
⚙️ Here's what we'll cover:
00:00 - Intro: The Problem with Scaling Distributed Systems
00:40 - Consistent Hashing Recap (Why It Solves So Much Pain)
01:40 - 🛠️ Building the Basic Hash Ring
05:16 - ❗ What's Wrong with This Hash Ring?
06:39 - ⚖️ Adding Virtual Nodes to Balance the Load
09:00 - 🧨 Still Not Enough? Let’s Talk Real-World Failures
10:45 - 💾 The Data Loss Problem and How to Solve It
12:00 - 🔁 Data Redundancy in the Hash Ring (Let’s Code!)
15:09 - 🚀 Plug It Into a Caching Server
16:53 - 🔍 Recap: What We Just Built
17:25 - 🧠 What’s Next: Gossip Protocol, Atomicity, and Beyond
19:15 - 🧪 Your Turn: Build, Extend, and Share with Me!
📚 Want to understand the *concepts* before diving into code? Watch this first:
👉 [The Theory of Consistent Hashing](https://youtu.be/jb439MbzTAk)
💻 Access the full code on GitHub:
👉 https://github.com/architagr/The-Weekly-Golang-Journal/tree/main/consistent_hashing_distributed_cache
🎯 Don't forget to:
✅ Like this video if it helped
✅ Subscribe for more backend deep dives
✅ Comment if you want a full series on distributed systems in Go
#Golang #ConsistentHashing #DistributedSystems #BackendEngineering #SystemDesign
Ever used key % N and thought… “hey this is clever”? Yeah, I did too — until I added a server and broke my entire cache 🧨 In this video, I’ll walk you through the actual journey I went through to understand and implement consistent hashing — a core building block in scalable,...
Ever used key % N and thought… “hey this is clever”?
Yeah, I did too — until I added a server and broke my entire cache 🧨
In this video, I’ll walk you through the actual journey I went through to understand and implement consistent hashing — a core building block in scalable, distributed systems like Redis, DynamoDB, and Memcached.
🎯 What you’ll learn:
Why naive partitioning like key % N fails at scale
How hash rings and virtual nodes solve that pain
How to avoid hot spots and single points of failure
The role of replication in fault tolerance
💥 This is the theory part (with real-life examples).
🔧 Part 2: The actual code in Go — coming next!
Whether you're prepping for system design interviews or scaling your backend — this will level you up.
💬 Drop your questions, war stories, or memes in the comments. I read ‘em all!
🧠 Want the blog version? Coming soon on [The Weekly Golang Journal]
if you like to read I have also published this as an article
Linkedin - https://www.linkedin.com/pulse/consistent-hashing-explained-algorithm-doesnt-freak-out-agarwal-gqqbc
Medium - https://medium.com/@architagr/cb7edcefdf80source=friends_link&sk=da5daa2cea7b5338d8eac3ca2d19e50b
******** Table of contents ********
00:00 Setting the Scene: Why Caches Break at Scale
00:47 Modulo Magic? Distributing Keys with `key % N`
01:35 And… It Breaks: The Flaw in Modulo-Based Distribution
02:48 What Even Is a Hash Function?
03:46 What Makes a Hash Function “Good” for Caching
04:28 Meet the Hash Function Hall of Fame (MD5, SHA1, etc.)
04:57 Hash Functions Beyond Caching: Real-World Uses
05:27 The Hash Ring: The Core Idea Behind Consistent Hashing
09:34 Virtual Nodes: Your Secret Weapon Against Hotspots
13:54 Replication in Consistent Hashing: No More Ghosted Servers
16:40 TL;DR — What We Learned and What’s Next
#ConsistentHashing #SystemDesign #BackendEngineering #DistributedSystems #Caching #GoLang #DevTalk #HashRing #VirtualNodes
Wondering what design patterns are and why they're a game-changer in coding? Uncover the secrets behind these powerful coding blueprints that elevate your projects to a whole new level! Why learn design patterns? They're the shortcuts to elegant, scalable, and efficient code....
Wondering what design patterns are and why they're a game-changer in coding?
Uncover the secrets behind these powerful coding blueprints that elevate your projects to a whole new level!
Why learn design patterns? They're the shortcuts to elegant, scalable, and efficient code.
#DesignPatterns #SoftwareDevelopment #ProgrammingTutorial
Tags:
#designpatterns, #systemdesign, #lld, #solid #IntroductiontoDesignPatterns, #softwaredevelopment, #programmingtutorial, #Whataredesignpatterns, #learndesignpatterns, #theexceptionhandler, #coding #codingtutorial
******** Table of contents ********
00:00 Setting the context
00:40 Request to subscribe
00:50 What are Design Patterns and Why we should learn them
01:27 Classification of Design Patterns
01:37 Creational Design Patterns
01:45 Structural Design Patterns
02:01 Behavioural Design Patterns
03:13 Catalog of Design Patterns
First, we will provide an overview of the Abstract Factory pattern and explain its benefits. We will then discuss the different components of the pattern, including the abstract factory interface, concrete factory implementations, and the product families. Next, we will dive...
First, we will provide an overview of the Abstract Factory pattern and explain its benefits. We will then discuss the different components of the pattern, including the abstract factory interface, concrete factory implementations, and the product families.
Next, we will dive into a practical example that demonstrates how to use the Abstract Factory pattern to create and manage different types of vehicles. We will create abstract vehicle factory interfaces, concrete factory implementations for cars for different regions, and different spare part families for each type of car in different region.
We will also discuss the advantages of using the Abstract Factory pattern, including increased flexibility and maintainability, reduced code duplication, and improved testability.
By the end of this video, you will have a solid understanding of how to use the Abstract Factory Design Pattern in Go, and how it can help you write more flexible and maintainable code.
Link to the book: https://amzn.to/43kIiME
Link to the github repo for the code: https://github.com/architagr/design_patterns
#GoLangDesignPatterns #AbstractFactoryPattern #GoLangProgramming #ObjectOrientedDesign #SoftwareArchitecture #CodeDesign #CleanCode
#theexceptionhandler #softwaredesignpatterns
The Factory Design Pattern is a creational design pattern that provides an interface for creating objects in a super class, but allows the subclasses to alter the type of objects that will be created. In .NET, this pattern is commonly used to encapsulate object creation logic...
The Factory Design Pattern is a creational design pattern that provides an interface for creating objects in a super class, but allows the subclasses to alter the type of objects that will be created. In .NET, this pattern is commonly used to encapsulate object creation logic and promote loose coupling between classes, making the code more flexible and easier to maintain.
The Factory Design Pattern allows you to define a common interface for creating objects, but defer the object instantiation to the subclasses, which can implement the interface and decide which type of object to create based on the specific context. This approach enables you to decouple the code that uses the objects from the code that creates them, and promotes the Single Responsibility Principle.
In .NET, you can implement the Factory Design Pattern using various techniques, such as simple factory, factory method, or abstract factory
Link to the book: https://amzn.to/43kIiME
Link to the github repo for the code: https://github.com/architagr/design_patterns
#FactoryDesignPattern #DotNetDesignPatterns #SoftwareDesignPatterns
#ObjectOrientedProgramming #CleanCode #CodeQuality
#CSharpProgramming #DesignPatternsInDotNet #FlexibleCode
#MaintainableCode
https://youtu.be/1CCVh0z94jU
Factory design pattern is one of the most popular design patterns. This type of design pattern comes under creational pattern as this pattern provides one of the best way to create an object. Here we explained factory design pattern in Go (Golang) with code and real example....
Factory design pattern is one of the most popular design patterns. This type of design pattern comes under creational pattern as this pattern provides one of the best way to create an object.
Here we explained factory design pattern in Go (Golang) with code and real example.
Link to the book: https://amzn.to/43kIiME
My GitHub link : https://github.com/architagr/design_patterns
#FactoryDesignPattern #SoftwareDesignPatterns
#ObjectOrientedProgramming #DesignPatterns #CreationalPatterns
#ProgrammingTips #CodeExamples #softwaredevelopment
Here we start our new series on Design Patterns . So I am Starting with the basics of Design Patterns !! I really hope you like this Series. Benefit of using or learning design patterns 1. Help design software fast based on knowledge of experienced developers, who have...
Here we start our new series on Design Patterns .
So I am Starting with the basics of Design Patterns !! I really hope you like this Series.
Benefit of using or learning design patterns
1. Help design software fast based on knowledge of experienced developers, who have already faced the similar issue.
2. Helps is better communication with team member as we start using common dictionary.
3. Better code Extensibility, as now we do not have to focus on updating existing code while adding new feature.
4. better code Maintainability.
5. Better code Readability.
#designpatterns #systemdesign #theexceptionhandler
In this video, we'll be discussing a roadmap to learn data structures and algorithms. We'll be focusing on how to crack your first FAANG interview. If you're looking to learn basic data structures and algorithm basics, then this is the video for you! We'll talk about how to...
In this video, we'll be discussing a roadmap to learn data structures and algorithms. We'll be focusing on how to crack your first FAANG interview.
If you're looking to learn basic data structures and algorithm basics, then this is the video for you! We'll talk about how to study for these exams, what resources you need, and how to approach the material. After watching this video, you'll be ready to tackle your first FAANG interview!
You can reach out to me here for any guidance:
https://docs.google.com/forms/d/e/1FAIpQLScnTSUzy84lbX044fMtBkGSF9zDJ0g-uVKSAsaM6xK4Zqfqww/viewform
Do like, share and comment it motivates me and helps me make more amazing content for you!
#datastructures #algorithm #faang #interview #preparation #lld #hld #competitiveprogramming #learncoding #programming #learning #scaler #theexceptionhandler #scalereview