"High Performance with MongoDB" book is out now. Written for MongoDB engineers.

✨ A tiny MongoDB trick that saves big headaches Most devs update numbers like this: Fetch → Change → Save. That’s slow, heavy, and risky when many updates happen at once. Instead, use "$inc". 🚀 It directly tells MongoDB: “increase (or decrease) this value by X.” 👉 Perfect for: • subscribersCount • views • scores ✅ Atomic updates ✅ Less DB load ✅ One clean line of code Why fetch when $inc can do it smarter? Have you tried it yet? #mongodb #mongoose #backend

🛠️ Using .explain() to Diagnose Slow MongoDB Queries During Peak Load While investigating increased read latency during peak traffic, I found the MongoDB .explain() method invaluable for pinpointing performance bottlenecks. By analyzing the query execution plan, .explain() provided detailed visibility into: - Index selection - Document scan count - Execution stats (e.g. executionTimeMillis, totalDocsExamined, totalKeysExamined) This helped surface inefficient queries that weren’t leveraging indexes optimally — something that’s easy to overlook until traffic scales. It’s a small but powerful diagnostic tool that should be part of every MongoDB performance tuning workflow. #MongoDB #QueryOptimization #PerformanceEngineering #ScalableArchitecture #TechDeepDive

Proud to showcase my MongoDB Indexing Design Fundamentals from MongoDB. This badge validates my expertise in designing efficient indexes to speed up queries and reduce resource consumption in MongoDB. Having struggled with large index sizes in the past, this course highlighted some excellent strategies. I wanted to share my key takeaways on how to efficiently manage and optimize MongoDB indexes. 1. Embrace Partial Indexes: This is a game-changer. Instead of indexing all documents in a collection, partial indexes only index documents that meet a specific filter. This drastically reduces the index size, saving disk space and memory, without sacrificing performance for your most critical queries. 2. Regularly Review Your Indexes: A large index size can be a sign of a bloated system. I learned the importance of reviewing existing indexes at least once a quarter. This helps you identify and remove redundant or unused indexes that are consuming valuable resources for no good reason. 3. Test with Hidden Indexes: Dropping an index can be risky. That's where hidden indexes come in. This feature allows you to temporarily remove an index from the query planner's consideration. You can safely test the impact on your queries before committing to a permanent deletion. 4. The ESR Strategy for Compound Indexes: When building compound indexes, the Equality, Sort, Range (ESR) strategy is a must. It dictates the optimal field order: place fields for exact matches first, followed by fields for sorting, and finally, fields for range queries. This ensures the index is used as efficiently as possible. 5. Understand Low Cardinality Fields: A query on a low-cardinality field (one with very few unique values) can often return a large number of documents. For this reason, these fields are generally poor candidates for a standalone index. However, they are highly effective when used as the first field in a compound index to quickly narrow down the results for a more selective query. These strategies provide a solid framework for building and maintaining a healthy, high-performing MongoDB database. I'm looking forward to applying these concepts in my work! Another very useful video: Solving the Mystery of Index Use https://lnkd.in/gFy3a3fm #MongoDB #DatabaseOptimization #Indexes #DataManagement #Learnin

Think scaling MongoDB is hard? MongoDB Atlas makes vertical scaling automatic. Need more? Scale across multiple nodes with options based on how your data behaves. Scaling is supposed to be simple—and with MongoDB, it is. Want more myths cleared up? Check this playlist. 👇 https://lnkd.in/ddxRbfB6

Issue #339 of Off-by-none is out! In this issue, AWS launches its API MCP Server, Supabase passes GO and collects $100M, and the Data API Client v2.0 gives serverless Postgres and MySQL users fewer headaches. #offbynone https://lnkd.in/ef34w5un

When my colleagues Akshat Vig and Ashish Kumar joined MongoDB, they brought their extensive experience from Google and Amazon Web Services (AWS) to a rich tradition of MongoDB development. An aggregation, if you will... 🥁 In this new MongoDB Engineering Blog post, they share their vision of the key themes that shape how our Engineering team works to help developers get to production fast: Resilience - providing a system that anticipates failure and recovers automatically Intelligence - Vector search and AI capabilities built directly on your operational data Simplicity - Multi-cloud that works with a single API, turning operational headaches into simple deployment choices. The goal isn't just a better database but enabling true developer agility. Check out the full blog post: https://lnkd.in/gbA_kX-d

Redis is single-threaded… but still insanely fast. How? Let’s break it down. ⚡ Everything stays in memory, so lookups happen in nanoseconds instead of milliseconds. ⚡ Single-threaded event loop means no messy locks or race conditions. With I/O multiplexing, Redis can juggle thousands of connections without breaking a sweat. ⚡ Its data structures aren’t generic, they’re highly optimized for both performance and memory efficiency. ⚡ The network side is super lean too, using a simple text protocol (RESP) and pipelining so multiple commands travel together. ⚡ And when you need more complex operations, Redis runs Lua scripts right on the server, so you cut down roundtrips and keep everything atomic. Every time I read about Redis internals, I’m amazed at how much thought went into designing something both simple and absurdly fast. What’s your favorite Redis feature that makes it stand out? #Redis #BackendDevelopment #SystemDesign #Databases #HighPerformance #LearnWithNayan Credits: https://lnkd.in/dP5PXphB

🚀 How We Cut Redis Memory Usage in Half with a Simple Laravel Optimization Our Redis queue was running at 99% memory, slowing jobs and causing timeouts. The culprit? Bloated job payloads — we were pushing full models into Redis. The fix was simple: queue only the IDs, and load data inside the job handler. Result → Redis memory dropped to ~50%, latency vanished, stability soared. Read the full story 👇 🔗 https://lnkd.in/d6YPhGGf

Last week, we migrated from AWS ElastiCache to a self-hosted Redis VM. Straightforward plan, right? Spin up a VM, restore snapshot, plug it back into Celery. Except this time… our entire AutoPay engine decided to go rogue. We use Redis not just as a cache, but also as a Celery broker for thousands of recursive AutoPay tasks basically, each user’s SIP runs as a self-scheduling task. The flow looks like this: . Task executes business logic (debit, notify, etc.) . Reads metadata (user_id, frequency, mandate_id) . Schedules itself for the next run . Keeps doing this until base case hits that is the user cancels their SIP Basically recursion, but in production. Now, during migration we had two Redis partitions: DB 1 → caching layer DB 2 → broker queue (stores all user scheduling metadata) The Redis snapshot restored fine same size as before but DB 2? Completely nuked. Just random ack keys, no valid queues. That meant every user’s SIP scheduling data gone. If this had persisted, it would’ve been a serious hit both on revenue and user trust. After multiple restore attempts failed, and the broker queue was not able to pick any task from the db even after re-configuring the beats schedule Then we switched to manual mode: Fetched all active SIPs from Postgres, extracted their metadata, and recreated each Celery task instance programmatically. Since the scheduling logic already existed in code, each task re-registered itself and scheduled its next ETA automatically. A few hours later: The queue was alive again. Daily and monthly tasks restored, AutoPay notifications firing normally from 4 AM. (just a bit of delay by an hour or so for one day) 💡 Key takeaway: Never rely on ephemeral broker data during infra migrations and even if you have persisted data, always double-check the format on the destination sometimes what your previous provider could read gets straight-up rejected or dumped as junk by the new one. #AWS #Infra #Redis #Queue

Two years ago, we might have been thought of as a fast, flexible NoSQL option. Today, MongoDB is the database many mission-critical systems trust. In this blog, we reflect on how MongoDB has matured—introducing ACID transactions, sharding, strong security & compliance, and enterprise-grade availability. If you’ve ever wondered whether to use MongoDB for your most critical workloads, it’s time to take a fresh look. 👀✨ Read the full story of our journey and what’s ahead. https://lnkd.in/gi77WTx3