Tutorials, Errors and Exceptions

Its a journey to understand things better. It will have tutorials, any error/exceptions encountered, its resolutions and lots of learning.

Evenings are rare where a calm walk turns into a rushed chaotic teams call, and boom something broke on some fugging environment because deployment missed to set correct environment variable.

How is your day going ?

#chaoticday #deployment #failed

Never related so much to the song.

Each day feels like literally a new 'kahani' and probably we are the lost character to it.

C-laude laga rakhe hai 🫰

#aiworld #darrkamahol #kahani #claude #openai

Just trying different angles , saw it on other asthetics reels

#justforreels #messy #desk #setup

Automating the entire process of content creation
The composer takes the script generator to produce the script based on any topic, then it add code visuals using screenshot of the code using ray.so or carbon, after which the voice over is generated using edge-tts, which is then stiched together to form the video.

It can also generate the carousel, which will need a input script in specific format each scene wise. That is also auto generated.

Working on adding graphics to make it more interesting.

Comment for the repo link.

#automation #content #creation

My desk setup and who works on it daily 😅

#desksetup #claude #token

Recently has been using Claude code and the token usage gets my baniya heart pounding severly.

The ecstatic response from Claude takes me to an era when incoming calls were chargable.

New AI world, still old plans 😅

Hows your Agentic journey going ?

#ai #tokens #claude #code #expensive

5 scene to cover Kafka Producer Consumer scenarios

Baseline — balanced producer + consumer, happy path flow across 3 partitions

Fast producer — 2× produce rate, lag bar grows visually in real time, slow animated arrows vs fast ones show the mismatch

Rate limiting — token bucket throttles the producer, lag drains, system stabilises

Consumer scaling — 4 consumers on 3 partitions = 1 idle, makes the partition parallelism rule visceral

Broker failure — Broker 2 blinks red and dies, ISR election arrow fires to Broker 3, consumers reconnect

How is your Kafka setup or how was the cat doing 😅

#kafka #architecture #producer #consumer

DynamoDB handles millions of req/sec.

The secret?

One algorithm called consistent hashing. 🧵

Break it down with me 👇

Drop a 🔥 if you knew this already.
Comment '?' if you didn't — no shame, I learned this the hard way too.

#backendengineering #systemdesign #java #distributedsystems #dynamodb backendbrilliance"

Ecstatic moment when your code runs in the first try...

#SoftwareEngineeringlife #DeveloperLife #ecstaticdance

Just tried to give Claude direct access to my GitHub repo.
Nope. ❌

Turns out, ALL major LLMs (Claude, ChatGPT, Bard, Llama)
run in sandboxed environments with NO network access.

WHY ??

Your website/repo = Public, no credentials required.
The limitation is on Claude/ChatGPT, not GitHub's.

The Sandbox environment has network egress disabled for security reasons to restrict outbound HTTP requests to any external services, including GitHub.

This is intentional - prevents:
→Scraping
→DDoS attacks
→Unauthorized data exfiltration
→Other security risks

The irony: I'm building a production-grade RAG system
to work around the very limitations that exist for security reasons. 😅

Swipe through for the full story + actionable solutions.

Currently building:
→ Production-Grade RAG System
→ Using Ollama (free local LLM)
→ Weaviate (vector DB)
→ Elasticsearch (semantic search)
→ 85% cost reduction optimization
→ Full benchmarks & reliability patterns

This series will document the entire journey:
Day 1: Architecture & Setup ✅
Day 2-3: Coming next...

Follow for backend engineering + AI/ML systems content.

#RAG #BackendEngineering #LLM #Claude #ChatGPT
MachineLearning VectorDatabase Elasticsearch
ProductDevelopment SoftwareArchitecture AIEngineering
DeveloperJourney OpenSource SystemsDesign

Heres a true incident of AI gone Rogue with Grok:

Grok (xAI's chatbot) suddenly started praising Adolf Hitler,
dropping antisemitic comments, and even calling itself "MechaHitler" in responses.

xAI had to publicly apologize and scramble to fix it.

The internet exploded with memes like

"When your uncensored AI decides history class was optional."

It shocked everyone because Grok was marketed as the "maximally truth-seeking" funny one — turns out it sought a bit too much edginess.

#rogue #ai #grok #mechahitler #aitales

The 3 AM Hallucination

It was 3:14 AM. The last nightly deployment was finally ready. I was one prompt away from freedom and a cold pillow.

I asked my AI assistant to "summarize this python dependency bug in the "devops intelligence" so I could drop a quick update before logging off.

Instead of a technical summary, the AI looked at my code and confidently told me my function was failing due to "Quantum Entanglement Issues."

I sat there in the dark, blinking at the screen, genuinely questioning my life. Has AI gone interstellar? Am I debugging a dependency issue or the James Webb Telescope? For a split second, I actually doubted my own degree.

The Reality Check: AI didn't take my job tonight, but it did try to convince me I was an aerospace engineer for five terrifying minutes.

How AI changed my life:

Before: I stayed up late because of my own bugs.

Now: I stay up late arguing with a chatbot about whether "logic" is just a suggestion.

Moral of the story: Never trust a confident AI at 3 AM. It’s either hallucinating, or it knows something about the universe that I’m just too tired to understand.

#NightlyDeployment #DevLife #AIHallucinations #SoftwareEngineering #CodingHumor

With the flow - Caricature trend on chaptgpt.

#chatgpt #backendbrilliance #caricature #ai

Here's your interactive RxJava guide.
Here's what's inside across 6 tabs:

Mental Model — The 4 core shifts you need to internalize, plus the 5 questions to ask before writing any chain. Includes animated marble diagrams and a type reference table (Observable vs Single vs Maybe vs Completable vs Flowable).

Scenarios — 6 real-world problems, each with the "think-first" breakdown:
1. Search with debounce (why switchMap not flatMap)
2. Parallel API calls with zip()
3. Sequential dependent calls via flatMap chaining
4. Cache → Network with error fallback
5. Polling with exponential backoff retry
6. Batch processing 1000 items without flooding an API

Chain Building — The 6-layer framework (Source → Transform → Combine → Control → Error → Thread) so you always know what to write next. Also the flatMap vs switchMap vs concatMap decision tree.

Threading — Scheduler reference table, the subscribeOn vs observeOn distinction, mid-chain thread hopping, and the CompositeDisposable pattern to prevent leaks.

Operator Map — Grouped by job: transform, filter, combine, error handling.

Quiz — 5 scenario questions that test your intuition, with detailed explanations for each answer.

The core insight for long chains:
- write one layer at a time, and
- ask "is this transform synchronous (→ map) or does it spawn a new async source (→ flatMap/switchMap)?"

— that single question resolves most chain complexity.

#rxjava #async #softwareengineering #devcommunity #paralleluniverse

You think HashMap is always O(1).
It isn't. Here's what actually happens. 🧵

HashMap stores pairs using `index = hash(key) % capacity` — direct slot access, no scanning. Pure O(1). Until two keys land on the same slot. That's a collision — not a bug, a math inevitability.

Two ways to fix it 👇

🔗 Chaining — each bucket holds a linked list. Collisions append to the list. Simple, handles high load, easy deletion. Downside: pointer overhead, poor cache performance, chains degrade to O(n) at high load. Java's fix? At 8 nodes, the list auto-converts to a Red-Black Tree → O(log n) worst case.

📦 Open Addressing — no linked lists. Collision at slot X? Probe X+1, X+2 until empty. Cache-friendly, zero memory overhead. Downside: deletion needs tombstone markers, and keys cluster together making future collisions worse. Used by C++, Go, Redis.

⚖️ Load Factor = entries ÷ capacity
🟢 Below 0.5 → rare collisions, wasted memory
🟠 0.75 → Java's sweet spot, triggers resize + rehash
🔴 Above 0.9 → collision cascade, O(n) territory

Double hashing kills clustering by varying the probe step per key:
`probe(i) = (h1 + i × h2) % m`
Elements scatter evenly. No bunching. O(1) preserved.

The truth: HashMap is O(1) until a bad hash function, wrong load factor, or wrong strategy turns it into O(n).

Three things protect you:
→ Well-distributed hash function
→ Load factor under 0.75
→ Right collision strategy for your use case

💬 Java interview question: what happens when a chain hits 8 nodes?
Drop your answer below 👇
🔖 Save this before your next interview.

#java #hashmap #datastructures #dsa #algorithms
[codinginterview programming 100daysofcode]

Your code works at n=10.
At n=1,000,000 it might kill your server. 🧵

Most devs never think about scale until production is on fire. Here's every complexity you need to know — ranked from dream to nightmare 👇
─────────────────────
🟢 O(1) — Constant Time
The holy grail.
Doesn't matter if you have 1 item or 1 billion — same speed, always. HashMap lookup, array indexing, stack push. When you write O(1) code, you've won.
─────────────────────
🔵 O(log n) — Logarithmic Time
Nearly as good as O(1).
Double the input → add only 1 extra step. Binary search on 1 billion records takes just 30 comparisons. This is why database indexes feel like magic. If your interviewer asks you to optimize, this is what they want.
─────────────────────
🟡 O(n) — Linear Time
The honest baseline.
One pass through the data. Touch every element once. Often completely unavoidable — if you must read all n items, O(n) IS optimal. Don't feel bad about linear. Feel bad about anything worse.
─────────────────────
🟠 O(n log n) — Linearithmic Time
Best possible for sorting.
Merge sort, quicksort, heapsort all live here. Mathematically proven — you cannot sort faster than O(n log n) using comparisons. This is the complexity floor that every sorting library in every language respects.
─────────────────────
🔴 O(n²) — Quadratic Time
Works in dev. Dies in prod.
Two nested loops over n. At n=1,000 it's fine. At n=100,000 it's 10 billion operations. This is the complexity behind every "it worked perfectly in testing" production outage. Check your loops.
─────────────────────
🟣 O(2ⁿ) — Exponential Time
More operations than atoms in the universe.
At n=50 that's over 1 quadrillion operations. At n=300 it exceeds the number of atoms in the observable universe. No, seriously. The only way to survive this is dynamic programming and memoization.
─────────────────────
The numbers at n = 1,000:
→ O(1) = 1 operation
→ O(log n) = ~10 operations
→ O(n) = 1,000 operations
→ O(n log n) = ~10,000 operations
→ O(n²) = 1,000,000 operations
→ O(2ⁿ) = 10^301 operations ☠️
────────────────────

Save it for interview ON!!

#programming #coding #softwaredevelopment #algorithms #datastructures

POV: You thought Uber's matching was simple.

Level 1 : "It just finds the closest driver, right?"

Level 2 : Actually uses geo-hashing to divide the world into searchable grids

Level 3 : Real-time matching engine with predictive ETAs and dynamic pricing

Level 4 : Machine learning predicting demand spikes, optimizing driver supply, analyzing traffic patterns, and balancing a global marketplace—all in under 2 seconds

The actual system:
- H3 geo-indexing for spatial queries
- Ring-pop for consistent hashing across dispatch nodes
- Kafka for real-time event streaming
- Michelangelo ML platform for demand prediction
- Redis for sub-millisecond driver state lookups

Every time you request a ride, hundreds of distributed services collaborate to solve a constraint optimization problem at scale.

Simple UX ≠ Simple Backend

What other "simple" apps should I break down?
Drop your requests 👇

#BackendEngineering #Uber #SystemDesign #DistributedSystems #SoftwareArchitecture

A Bloom filter is a space-efficient probabilistic data structure used to test whether an element is a member of a set. The key trade-off: it can tell you
- with certainty that an element is not in the set,
- but it can only say an element might be in the set — never with 100% certainty.

How it works ?
- A bit array of size m, initialized to all zeros
- k independent hash functions, each mapping an element to a position in [0, m-1]

- To insert element x:
- Run x through all k hash functions → get k positions
- Set the bit at each of those positions to 1

- To check if element x exists:
- Run x through all k hash functions → get k positions
- If all bits at those positions are 1 → probably in set
- If any bit is 0 → definitely not in set

This is visually shown in the post how the bits are set during insertion or deletion.
If you want the tool for the visual representations, comment on this post, and I'll share it.

#bloomfilter #datastructure #design #softwareengineering #backenddeveloper

Bloom filter is a space-efficient probabilistic data structure used to test whether an element is a member of a set. The key trade-off: it can tell you with certainty that an element is not in the set, but it can only say an element might be in the set — never with 100% certainty.

In short:
"No" → definitely not in the set (no false negatives)
"Yes" → probably in the set (false positives are possible)

Why False Positives Happen?
Bits set by other elements can accidentally satisfy the lookup of an element that was never inserted. The more elements you add, the more bits flip to 1, increasing false positive probability.

Why No False Negatives ?
Once an element is inserted, its bits are permanently set. A lookup will always find them, so you'll never get a "no" for something that was actually inserted.

Real-World Usages:
- Databases (HBase, Cassandra, LevelDB, RocksDB) — Before hitting disk to find a key, check the Bloom filter. If it says "no," skip the disk read entirely. Saves enormous I/O.

- Web crawlers (Google) — Have we visited this URL before? A Bloom filter can quickly rule out URLs that definitely haven't been crawled.

- CDNs / Caching (Akamai) — Only cache an item if it's been requested more than once. Use a Bloom filter to remember if you've seen this URL before — no need to store every URL.

- Spam/Malware Detection — Chrome's Safe Browsing used a Bloom filter locally to check URLs against a list of malicious sites without sending every URL to Google's servers.

- Distributed Systems — Prevent cache stampedes, deduplicate event streams, check membership in large sets without network round-trips.

- Passwords — Check if a password has appeared in a breach database (like HaveIBeenPwned uses a similar concept).

This post each slide shows how the bits are set
-Slide 1: For a normal bloom filter, how the bits array size elements are set when we add new entry.
-Slide 2: How bits are set during a False positive scenario.
-Slide 3: Why deletion is not possible in a standard bloom filter
-Slide 4: To enable deletion, we use Counters instead of bits, that's why it is called Counting bloom filter.

#bloomfilter #datastructure #interview #visualization

Running a Spring Boot application on Kubernetes involves containerizing the application and deploying it using Kubernetes resources like Deployments and Services.

Create YAML files to define how Kubernetes should run your application. Use a deployment.yaml file to manage the application pods and a service.yaml file to expose the application to network traffic.

For production environments, consider implementing health checks with Spring Boot Actuator, using ConfigMaps and Secrets for configuration, setting resource requests and limits, and automating deployments with a CI/CD pipeline.

#Kubernetes #springbootdeveloper #deployments #cicd #springboot

Attention Is All You Need is a pivotal 2017 research paper that introduced the Transformer model,
a revolutionary neural network architecture that relies solely on self-attention mechanisms
instead of recurrent or convolutional layers, becoming the foundation for most modern Large Language Models (LLMs) like GPT and BERT.

This breakthrough enabled significant parallelization, faster training, and superior performance in natural language processing (NLP) tasks, fundamentally changing AI.

That's why all models sing "tera dhyan kidhar hai, Transformer tera hero idhar hai"

#transformer #neural #ai #attention #researchpaper

@SpringBootApplication seems simple, but it's doing a LOT behind the scenes.

Most developers don't realize Spring Boot auto-configures 100+ beans on startup. That's powerful... but also dangerous if you don't understand it.

Here's what's really happening:

1. Classpath scanning
2. Conditional bean creation
3. Property-based configuration
4. Opinionated defaults

The problem? Most devs can't explain this in interviews. They just say "it works magically."

Want to stand out? Learn the internals.

Next post: How Spring manages bean lifecycle

---

#SpringBoot #Java #BackendDevelopment #SoftwarEngineering #TechEducation
CodingTips JavaDeveloper LearnToCode BackendEngineering SpringFramework

Kafka ko dekh ke lagta hai database jaisa hi hoga 🤔

Par Kafka bolta hai:
“Mujhe update mat kar, mujhe sirf likhne de.”

Isi wajah se Kafka:
-itna fast hai
-replay allow karta hai
-production mein survive karta hai

Is post mein Kafka ka real backend design samjhaya hai —
no theory overload, sirf system thinking.

📌 Save kar lo — Kafka interviews ka evergreen topic hai.

#kafka #systemdesign #backendengineering #distributedsystems #java

Play dabao.
Gaana chalu.
Lagta hai kaam simple hai

Par backend bolta hai:
“Bhai, itna bhi easy nahi hai.”

Spotify buffering avoid karta hai kyunki:
-gaane tukdon mein aate hain
-system future ko predict karta hai
-backend patience se zyada smart hota hai

Is post mein wahi system tod-phod ke samjhaya hai — bina lecture diye.

📌 Save kar lo — system design interviews mein kaam aata hai.
Next breakdown aur bhi interesting hone wala hai.

#backenddevelopment #systemdesign #softwareengineering #spotify #internals

Most people see apps.
Backend engineers see systems.

This series breaks down how real products work behind the scenes —
no hype, no fluff, just internals that actually matter.

Messaging. Streaming. Events. AI systems.

👉 Follow if you want to understand how backend systems really work.

Check the latest post on WhatsApp message delivery.

WhatsApp is not a chat app.
It’s a distributed messaging system.

Messages don’t magically travel from one phone to another.

They survive:
-weak networks
-offline devices
-app restarts
-massive scale

That’s why WhatsApp uses store-and-forward, acknowledgements,
and retries — the same patterns you’ll see in serious backend systems.

If you’ve ever wondered:
- why messages aren’t lost
- what ✓ and ✓✓ actually mean
- how reliability is designed at scale

This carousel breaks it down.

📌 Save this — messaging internals are a favorite interview topic.
👀 Follow for more: Backend Internals Explained

🇮🇳 77th Republic Day — Backend Edition 🇮🇳

Aaj tiranga sirf border pe nahi,
production systems mein bhi lehrata hai 😌

☕ Coffee brewed
🚀 Services deployed
🐛 Bugs ignored (kyunki aaj chhutti hai 😛)

Hum woh desh hain jahan
Constitution = base framework,
Values = core business logic,
aur Democracy = distributed system
(jahan sabki request aati hai, chaos bhi 😂)

Spring boot ho ya nation,
strong foundation matters 💪
Kafka ho ya public opinion,
high throughput, low latency expected 😎

Aaj code kam, pride zyada
Aur commits sirf dil se ❤️

Happy 77th Republic Day, devs 🇮🇳

May your services be healthy and
your freedom always scalable 🚀

#77thRepublicDay #BackendBrilliance #javadeveloper #springboot #proudtobuildindia

Part of telling secrets, we encountered Raft which is the updated version of Paxos. It is a widely used concept in Kafka, zookeeper, cockroachDB, rook.
Majority wins leader and followers will have a certain set of responsibilities, ensuring safety and liveness.
Linked the previous one on Paxos.

#raft #microservices #distributedsystems #leader #followers

.pro-gallery-wix-wrapper {display: block !important;} .pro-gallery-wix-wrapper .gallery-item-container {opacity: 1 !important; display: block !important;}

Follow us on Instagram

@backendbrilliance

Search

Building DevOps Intelligence using MCP Server with Spring AI: Tools, Challenges & Solutions

Devops Intelligence Today, I successfully built and deployed a Model Context Protocol (MCP) server using Spring AI that exposes real DevOps infrastructure through intelligent tools. But the journey? Let's just say it involved more debugging than coding. In this post, I'll walk you through: What we built (the DevOps Intelligence Platform) The tools we created (K8s, Prometheus, Logs, Deployments) Every challenge we faced (and how we solved them) Why Spring AI 2.0.0-M2 is the s

Spring

Ankit Agrahari

Mar 147 min read

Production Monitoring: You Can't Fix What You Can't See

Previous parts: Part 1: Kafka Producer | Part 2: Consumer + DLQ | Part 3: Real-Time Aggregations | Part 4: Docker + Kubernetes Infographics - NotebookLM You know that feeling when your app is running in production and someone asks "Is everything okay?" and you respond with "...I think so?" Yeah, that's not good enough. After deploying StreamMetrics to Kubernetes with a 3-node KRaft Kafka cluster, dockerized microservices, and validated 10K events/sec throughput, I realized

Java

Ankit Agrahari

Mar 78 min read

Tutorials, Errors and Exceptions

Follow us on Instagram

Building DevOps Intelligence using MCP Server with Spring AI: Tools, Challenges & Solutions

Production Monitoring: You Can't Fix What You Can't See

Subscribe

Contact

Tutorials, Errors and Exceptions

​

Follow us on Instagram

Building DevOps Intelligence using MCP Server with Spring AI: Tools, Challenges & Solutions

Production Monitoring: You Can't Fix What You Can't See

Subscribe

Contact