AI can learn physics without equations. LLMs can synthesize commentary without understanding.

Our 4MB JSON Blob Brought #Postgres to Its Knees From 30s load times to 300ms with one surprising shift We were building a visual UI builder at Vade AI. Each interface was stored as a giant jsonb field in @postgres . It started small. Then one day... it hit 4.2MB. Every page load meant: 🔹 Fetch TOASTed blob 🔹 Decompress 4MB 🔹 Parse deeply nested JSON 🔹 Send it over the wire Result? -> 15–30 second load times. -> Users were making coffee while waiting 😅 ✅ Solution 1: Normalize it. 𝐖𝐞 𝐦𝐨𝐯𝐞𝐝 𝐭𝐨: 𝐧𝐨𝐝𝐞 𝐭𝐚𝐛𝐥𝐞 for each component. 𝐧𝐨𝐝𝐞_𝐜𝐡𝐢𝐥𝐝𝐫𝐞𝐧 table for relationships. Reconstructed the tree using recursive CTEs. Textbook solution. Total disaster. Recursive CTEs took 10–30s for moderately complex trees. Why? ❌ Each level materialized intermediate rows ❌ Joins exploded exponentially ❌ Path tracking bloated memory Our beautiful query became a bottleneck. 𝐓𝐡𝐞𝐧 𝐢𝐭 𝐜𝐥𝐢𝐜𝐤𝐞𝐝: “Why are we building the tree in the database?” 𝐒𝐨 𝐰𝐞 𝐜𝐡𝐚𝐧𝐠𝐞𝐝 𝐨𝐮𝐫 𝐬𝐭𝐫𝐚𝐭𝐞𝐠𝐲: ✔️ Fetch flat data ✔️ Rebuild the tree on the client ✔️ Cache aggressively in memory The results were dramatic: • DB query time: 30s → 200ms • Tree build on client: 10–50ms • Total load time: Under 300ms • DB load reduced by ~90% • Debugging became easier too 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲𝐬: 1. Recursive CTEs don’t scale well with depth or width 2. Databases are great for storage, not complex hierarchy logic 3. Sometimes, simple flat data + smart client logic wins If you're storing trees as JSON or relying on recursive queries… 𝐀𝐬𝐤 𝐲𝐨𝐮𝐫𝐬𝐞𝐥𝐟: Could the client do it better? Are you optimizing in the wrong place? Been there before? Recursive query war stories welcome in the comments. Read full blog here: lnkd.in/dSpm-2sG

Why I Gave Up on Recursive CTEs (and You Might Too) The theory was perfect. The real world? Not so much. We were building a visual UI builder. Every screen was a tree of components. Naturally, we stored it as a jsonb blob in Postgres. One field, one UI tree. Easy. Elegant. Fast... ...until it became 4MB of nested chaos. 𝐄𝐯𝐞𝐫𝐲 𝐥𝐨𝐚𝐝 𝐦𝐞𝐚𝐧𝐭: • Fetching TOASTed data. • Decompressing. • Parsing huge JSON. • Shipping it over the wire. Users waited 30 seconds for the UI to load. Unacceptable. 𝐒𝐨 𝐰𝐞 𝐧𝐨𝐫𝐦𝐚𝐥𝐢𝐳𝐞𝐝. Each node became a row. Relationships tracked in a node_children table. Perfect! Now we could use recursive CTEs to rebuild the tree. Textbook stuff. Until… we ran the queries. Recursive query time: 8–30 seconds Why? -> Postgres materializes each recursion level. -> Joins explode at depth. -> Tracking path bloats memory. -> It doesn’t stream it builds the entire tree before returning anything. We optimized for weeks. Still slow. 𝐓𝐡𝐞𝐧 𝐭𝐡𝐞 𝐨𝐛𝐯𝐢𝐨𝐮𝐬 𝐡𝐢𝐭 𝐮𝐬: “𝑾𝒉𝒚 𝒂𝒓𝒆 𝒘𝒆 𝒃𝒖𝒊𝒍𝒅𝒊𝒏𝒈 𝒕𝒉𝒆 𝒕𝒓𝒆𝒆 𝒊𝒏 𝒕𝒉𝒆 𝒅𝒂𝒕𝒂𝒃𝒂𝒔𝒆?” We moved tree construction to the frontend. 𝐍𝐨𝐰 𝐰𝐞: Fetch flat data Rebuild trees in ClojureScript Cache in memory 𝐑𝐞𝐬𝐮𝐥𝐭? •DB time: ⬇️ from 30s → 200ms •Tree build: 50ms •UX: Sub-second loads 𝐁𝐨𝐧𝐮𝐬 𝐰𝐢𝐧𝐬: • Progressive rendering • Better error handling • Easier testing • Fewer headaches 𝐓𝐡𝐞 𝐥𝐞𝐬𝐬𝐨𝐧? Not everything belongs in the database. CTEs are great... until they’re not. Sometimes boring, flat data + smart client logic wins. Have you hit the recursive query wall before? What did you do?

Extensibility isn’t a “nice to have.” It’s how your system survives change. We all start with clean intentions: → “Just need to support 3 formats for now.” → “We’ll refactor when it gets messy.” → “This logic is simple enough.” But complexity doesn't arrive all at once; it creeps in. New use cases. New teams. New integrations. Suddenly, your once-tidy codebase is bristling with 𝐢𝐟-𝐞𝐥𝐬𝐞 trees, forks, overrides, and “v2” everything. 𝐇𝐞𝐫𝐞’𝐬 𝐭𝐡𝐞 𝐬𝐡𝐢𝐟𝐭: Don’t just design for what you know. Design for what you can’t predict. 𝐓𝐡𝐚𝐭’𝐬 𝐰𝐡𝐚𝐭 𝐞𝐱𝐭𝐞𝐧𝐬𝐢𝐛𝐥𝐞 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐢𝐬 𝐚𝐛𝐨𝐮𝐭: 1. Adding behavior without modifying core logic 2. Letting teams work in parallel without coordination chaos 3. Adapting fast, with confidence It’s not overengineering. It’s humility acknowledging that growth is inevitable. Tools like multimethods and protocols in #Clojure make this natural. But the mindset applies everywhere: → Can this grow without friction? → Can someone extend it without asking me? → Will this break in six months? If not, it’s not extensible, it’s just temporary. How do you design for the unknown? Drop your favorite extensibility patterns (or failure stories) read full blog here: lnkd.in/dTUiSZCX

This week, @Cursor , the beloved AI coding assistant, nuked its "Unlimited" plan. • $20/𝐦𝐨𝐧𝐭𝐡? Suddenly became ~225 requests. • 𝐏𝐨𝐰𝐞𝐫 𝐮𝐬𝐞𝐫𝐬? Burned through it in hours. • 𝐃𝐞𝐯 𝐜𝐨𝐦𝐦𝐮𝐧𝐢𝐭𝐲? Absolutely furious. 𝐁𝐮𝐭 𝐥𝐞𝐭’𝐬 𝐛𝐞 𝐫𝐞𝐚𝐥: The cursor’s mistake wasn’t pricing too high… It was priced like a traditional SaaS product in an AI-native world. Let me show you why that's a disaster waiting to happen. 1. 𝐀𝐈 ≠ 𝐒𝐚𝐚𝐒 Traditional SaaS has near-zero marginal cost. AI-native apps? Every user interaction costs real money. 2. 𝐓𝐡𝐞 𝐅𝐨𝐮𝐧𝐝𝐞𝐫 𝐃𝐢𝐥𝐞𝐦𝐦𝐚 You want usage to grow… But every success drains your wallet faster. I learned this the hard way. Launched our beta with 15 users. Burned $500 in 72 hours. Why? Each interaction triggered 5+ API calls. Multiply that at scale… you’re toast. 3. 𝐔𝐧𝐥𝐢𝐦𝐢𝐭𝐞𝐝 𝐢𝐬 𝐚 𝐋𝐢𝐞 Founders pricing AI tools with "Unlimited" plans are either: • Hiding limits (destroying trust) • Losing money (slow death) • Overpricing to subsidize whales (alienating core users) None of these are sustainable. 4. 𝐌𝐲 𝐍𝐞𝐰 𝐑𝐮𝐥𝐞𝐛𝐨𝐨𝐤 After my $500 wake-up call, I rebuilt our pricing from scratch: ✅ Usage-based ✅ Transparent ✅ Margins that make sense ✅ Value at every step And most importantly no surprises. hashtag#Cursor's fall is a warning. Not just about trust. But about the illusion that AI tools can run on SaaS economics. The next wave of AI-native startups will win not by hiding cost… …but by designing models that make success profitable, not punishing. Founders, how are you tackling AI pricing? Let’s compare notes. This entire ecosystem is still figuring it out together. Read full here: lnkd.in/diQB4VMp

If you're still pricing your AI product like a SaaS tool, you're not building a business you're building a time bomb. #Cursor “Unlimited” plan collapse isn’t a one-off. It’s the first domino. Most AI startups today are: • Hiding true costs • Subsidizing power users • Betting you won’t notice until they pivot Here’s the truth: "Unlimited" in AI is either a scam or a suicide mission.

#buildinpublic We added #Claude to Vade AI months ago. But today it runs through our own MCP server and that changes everything. Here’s a short demo of how it works feedback welcome. Stay tuned for a full demo and more feature update

Have you ever built something so deeply that the frameworks started getting in the way? I just published a new blog on how I ditched LangChain and built a production-grade AI streaming system from scratch using nothing but Clojure, transducers, and sheer obsession with performance. -> 15x faster. -> 22x less memory. -> Zero bloat. All signal. This one’s not your usual AI ops fluff it’s raw, painful, and loaded with real architecture decisions from the trenches. 𝐑𝐞𝐚𝐝 𝐡𝐞𝐫𝐞: bytes.vadeai.com If you’ve ever felt like you were duct-taping your AI app with random wrappers this will hit home.

I used to freeze every time I needed polymorphism in #Clojure. Should I use a multimethod? A protocol? Maybe just... write another function? Nine times out of ten, I’d chicken out and write a big ugly cond. It worked until it didn’t. 𝐅𝐚𝐬𝐭-𝐟𝐨𝐫𝐰𝐚𝐫𝐝 3 𝐦𝐨𝐧𝐭𝐡𝐬 𝐢𝐧𝐭𝐨 𝐚 𝐫𝐞𝐚𝐥 𝐩𝐫𝐨𝐣𝐞𝐜𝐭: -> One process-data function turned into 50 lines of nested cond. -> Spread across 3 namespaces. -> Touching 7+ places every time we added a new format. -> Testing became a nightmare. -> Adding Excel support made me cry. That was my wake-up call. 𝐇𝐞𝐫𝐞’𝐬 𝐰𝐡𝐚𝐭 𝐟𝐢𝐧𝐚𝐥𝐥𝐲 𝐜𝐥𝐢𝐜𝐤𝐞𝐝: Polymorphism isn’t about being clever. It’s about being extensible. It’s the difference between a system that evolves… and one that rots. 𝐍𝐨𝐰 𝐦𝐲 𝐫𝐮𝐥𝐞 𝐢𝐬 𝐬𝐢𝐦𝐩𝐥𝐞: ✅ Dispatch by type? → Protocols ✅ Dispatch by values or context? → Multimethods ✅ Need to extend without modifying? → Either works, just pick one And yes, protocols are 5x faster for type dispatch. But 100x maintainability matters more. If your cond keeps growing teeth, that’s your codebase begging for polymorphism. Trust me future-you will thank you. Have you ever hit this wall? Tell me your “just functions” horror story below.

Building a website an app that convert legacy Excel statements into ICAI-compliant formats Using my platform (still in works) would love a feedback vadeai.com/

We spent 6 hours debugging LangChain. Then we built the same thing in 20 minutes without it 2023: Everyone's building the next big AI startup. @langchain , #LangGraphAI, @crewAIInc frameworks promising no-code agents, smart memory, auto-orchestration. It looked magical. Until we tried to build something real. 😅 𝐖𝐞 𝐧𝐞𝐞𝐝𝐞𝐝: 1. A simple filter on semantic search results 2. Clean LLM API calls 3. Tool integrations 4. State & memory 𝐖𝐡𝐚𝐭 𝐬𝐡𝐨𝐮𝐥𝐝'𝐯𝐞 𝐭𝐚𝐤𝐞𝐧 𝐜𝐨𝐮𝐩𝐥𝐞 𝐨𝐟 𝐡𝐨𝐮𝐫𝐬 - Took couple of days (3 days to be exact) - Layers of abstractions - Cognitive load of learning new tool chain - 0 visibility into what was happening.. 𝐓𝐡𝐞 𝐭𝐫𝐮𝐭𝐡? Frameworks don’t remove complexity—they just hide it. And when things break (they will), you're stuck debugging someone else's architecture. So we threw the frameworks out. Built Vade AI from scratch: ✅ Direct API calls ✅ Clean wrappers ✅ Simple state mgmt ✅ Total control ~1,000 𝐥𝐢𝐧𝐞𝐬 𝐨𝐟 𝐜𝐨𝐝𝐞. 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧-𝐠𝐫𝐚𝐝𝐞. 𝐅𝐚𝐬𝐭. 𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐚𝐛𝐥𝐞. 𝐑𝐞𝐥𝐢𝐚𝐛𝐥𝐞. 𝐋𝐞𝐬𝐬𝐨𝐧: -> Frameworks are great for demos. -> But for production? -> Own your code. Understand your system. Feel the algorithm. The real gold wasn’t in the tools. It was in the clarity of building what we needed. Read full blog here: lnkd.in/d8WvJjTy

What They Don't Tell You About Production AI Systems The brutal gap between tutorials and reality. AI tutorials lie to you. They show 47 lines of code, perfect results, zero problems. But real-world AI? It’s chaos. Here’s what they don’t tell you: 𝐓𝐡𝐞 𝐂𝐨𝐬𝐭 𝐄𝐱𝐩𝐥𝐨𝐬𝐢𝐨𝐧 Demo: $47/month Real traffic: $23,000+ in 6 months Why? • Long prompts • Multiple retries • Streaming + memory = $$$ 23000+ 𝒍𝒆𝒕'𝒔 𝒕𝒐𝒏𝒆 𝒊𝒕 𝒅𝒐𝒘𝒏 𝒂 𝒃𝒊𝒕 - 𝒎𝒂𝒚 𝒃𝒆 𝒂𝒓𝒐𝒖𝒏𝒅 6000+ 𝐓𝐡𝐞 𝐒𝐩𝐞𝐞𝐝 𝐓𝐫𝐚𝐩 Tutorial: Instant answers Reality: • 2–8s LLM latency • 30s+ queues at peak • Users bounce after 7s 𝐓𝐡𝐞 𝐃𝐢𝐫𝐭𝐲 𝐃𝐚𝐭𝐚 𝐃𝐢𝐬𝐚𝐬𝐭𝐞𝐫 Clean JSON? Nope. You get: • Scanned PDFs •“final_FINAL_v3.docx” • 23 languages • Cat photos 🤦‍♂️ 𝐏𝐫𝐨𝐦𝐩𝐭 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 𝐇𝐞𝐥𝐥 ▪️Tutorial: “Summarize this” ▪️Reality: 15-line prompt with tone, logic, JSON formatting, privacy, confidence scores, and fallback rules. Welcome to prompt ops. 𝐈𝐧𝐭𝐞𝐠𝐫𝐚𝐭𝐢𝐨𝐧 𝐂𝐡𝐚𝐨𝐬 ▪️Demo: One API call ▪️Reality: • OAuth breaks at 3AM • Rate limits, SSL issues • Webhooks ghosting you • 17 dependencies, all fragile 𝐔𝐬𝐞𝐫𝐬 𝐀𝐫𝐞 𝐖𝐢𝐥𝐝 • Upload memes asking for tax help • Expect memory from last month • Blame the AI for legal docs they don’t understand 𝐌𝐨𝐧𝐢𝐭𝐨𝐫𝐢𝐧𝐠 𝐈𝐬𝐧’𝐭 𝐎𝐩𝐭𝐢𝐨𝐧𝐚𝐥 ▪️Monitoring Isn’t Optional ▪️It’s not just uptime. ▪️You need: • Token cost tracking • Accuracy drift • Hallucination detection • Human review flags • Compliance triggers 𝐀𝐈 𝐈𝐬𝐧’𝐭 𝐃𝐨𝐧𝐞 𝐀𝐟𝐭𝐞𝐫 “𝐈𝐭 𝐖𝐨𝐫𝐤𝐬” The real work starts after the demo. Can it handle real data, real users, edge cases, and failure? 𝐓𝐡𝐞 𝐎𝐧𝐥𝐲 𝐖𝐚𝐲 𝐭𝐨 𝐖𝐢𝐧? • Build monitoring first • Plan for failures • Keep humans in the loop • Expect wild data & wilder users • Budget 10x more than your tutorial said 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧 𝐀𝐈 𝐢𝐬 𝐧𝐨𝐭 𝐚 𝐩𝐥𝐚𝐲𝐠𝐫𝐨𝐮𝐧𝐝. It’s a minefield, and the people who survive it aren’t lucky. They’re prepared. Read full blog here: lnkd.in/d8WvJjTy

Will Future #Databases Still Use Pages? For decades, databases have relied on pages 4KB, 8KB, 16KB blocks to shuttle data between slow disk and fast memory. Not a design quirk. A survival strategy. -> RAM is fast but volatile. -> Disk is persistent but slow. -> The buffer pool sits in between caching hot pages, managing cold ones. 𝐁𝐮𝐭 𝐡𝐞𝐫𝐞’𝐬 𝐭𝐡𝐞 𝐛𝐢𝐠 𝐪𝐮𝐞𝐬𝐭𝐢𝐨𝐧: What happens when the boundary between memory and storage disappears? Enter: CXL (and RIP Optane) Intel Optane once hinted at a future with: • Terabytes of memory-accessible data • Persistence without power • Buffer pools? Optional. While Optane ended in 2022, its vision lives on now powered by Compute Express Link (CXL): Shared, byte-addressable, persistent memory across servers. No pages. No I/O blocks. Just addressable data. 𝐓𝐡𝐢𝐬 𝐬𝐡𝐢𝐟𝐭𝐬 𝐞𝐯𝐞𝐫𝐲𝐭𝐡𝐢𝐧𝐠: ✅ No page reads ✅ No buffer pool coordination ✅ No I/O unit mindset ✅ Just direct, persistent access 𝐒𝐨 𝐰𝐡𝐚𝐭 𝐛𝐫𝐞𝐚𝐤𝐬? Do we still need slotted pages? What happens to WAL? Is tuple layout even relevant? Databases like SAP HANA and NewSQL engines are already experimenting with hybrid models. 𝐖𝐞'𝐫𝐞 𝐞𝐧𝐭𝐞𝐫𝐢𝐧𝐠 𝐚 𝐧𝐞𝐰 𝐞𝐫𝐚 𝐰𝐡𝐞𝐫𝐞: 1. Memory becomes the new disk 2. Latency meets persistence 3. Pages become a relic of the past The future of databases might not be page-oriented But byte-addressable, persistent, and memory-native. Are your systems and skills ready for that shift? Read to learn more: lnkd.in/dbA8VSVH

Ever wonder where your SQL data actually goes? Beneath your *SELECT * lies a world of page headers, tuple bitmaps, and record IDs. We broke it all down byte by byte. 👉 bytes.vadeai.com/database-de… #Postgres #Database

The Real Cause of Our Data Loss Wasn’t #Postgres It Was This It was 3:12 AM on a Tuesday. ❗ Transactions failing ❗ Users locked out ❗ 50,000 records gone The logs screamed: page corruption detected At first, I blamed hashtag#PostgreSQL. But Postgres wasn’t the problem. 𝐓𝐡𝐞 𝐫𝐞𝐚𝐥 𝐜𝐮𝐥𝐩𝐫𝐢𝐭? A failing disk controller silently corrupting random writes no alerts, no logs, just invisible chaos. 𝐇𝐞𝐫𝐞’𝐬 𝐰𝐡𝐚𝐭 𝐬𝐚𝐯𝐞𝐝 𝐮𝐬: @postgres wasn’t crashing it was refusing to serve corrupted data: ✅ Checksums validated ✅ Broken pages rejected ✅ Write-Ahead Logs intact It wasn’t the villain. It was the canary in the coal mine. 𝐖𝐡𝐚𝐭 𝐭𝐡𝐢𝐬 𝐭𝐚𝐮𝐠𝐡𝐭 𝐦𝐞: Most of us treat databases like black boxes. We write SQL, deploy schema changes, and hope the magic works. But when the abstraction breaks you need to know: -> How a tuple is stored -> What a Record ID really points to -> How buffer pools manage memory -> Why “pages” exist in the first place Because when metal fails, software can only do so much. 𝐇𝐚𝐫𝐝𝐰𝐚𝐫𝐞 𝐚𝐛𝐬𝐭𝐫𝐚𝐜𝐭𝐢𝐨𝐧 𝐡𝐚𝐬 𝐥𝐢𝐦𝐢𝐭𝐬: 1. You don’t think about your disk controller until it eats your data. 2. You don’t think about torn pages until your queries break. Databases aren’t just APIs. They are physical systems built on very real hardware SSDs, RAM, controllers, caches, pages. 🚨 𝐈𝐟 𝐲𝐨𝐮 𝐫𝐮𝐧 𝐩𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧 𝐬𝐲𝐬𝐭𝐞𝐦𝐬: 1. Run disk integrity checks 2. Monitor page corruption errors (even rare ones) 3. Use server-grade storage with ECC RAM 4. Learn how your database physically stores your data Root-cause analysis begins with curiosity and ends with humility. Our data loss wasn’t because of bad SQL. It wasn’t even a bug. 𝐈𝐭 𝐰𝐚𝐬 𝐚 𝐫𝐞𝐦𝐢𝐧𝐝𝐞𝐫: abstractions are only safe… until they aren’t.