System Design From Zero: An Engineering Head Teaches His Nephew

Part 0: Why Smart Engineers Freeze in This Round 👦 Nephew: Uncle, I know Redis, MongoDB,...

dev.to

GitLab vs. MongoDB: Which Technology Stock Is a Better Buy in 2026? | The Motley Fool

Both GitLab and MongoDB saw robust revenue growth in 2026, but their paths to profitability and risk profiles reveal key differences for investors.

fool.com

Client Challenge

pypi.org

Client Challenge

pypi.org

Monlite – documents, vectors, cache, and job queue in one SQLite file

Every local AI agent project I start begins the same way — not with agent code, but with...

dev.to

Building My Personal Website From Scratch: Tech Stack, Architecture, and Lessons Learned

As a software engineer, a personal website is more than just an online resume it’s an open-ended canvas, a sandbox for testing new tech, and a reflection of how you approach software architecture. When I set out to build shubhkumar.in, I didn't want to just spin up a template or use a no-code builder. I wanted to build a production-grade, highly optimized, and scalable platform from scratch. Here is a look under the hood at the stack, the design decisions, the hosting setup, and the inevitable mistakes made along the way. ### The Tech Stack: Modular & Decoupled Instead of building a monolithic application, I opted for a decoupled frontend and backend architecture. This keeps the presentation layer lightweight while allowing the API to scale independently. * **Frontend:** **Next.js & Tailwind CSS.** Next.js handles the user interface with excellent performance, while Tailwind CSS keeps the utility-first design clean, responsive, and highly maintainable. * **Backend API:** **Express.js (Node.js).** Hosted at `api.shubhkumar.in`, this unopinionated framework handles dynamic requests and serves content efficiently. * **Database & Distributed Caching:** **MongoDB Atlas & Redis.** MongoDB Atlas acts as our fully managed cloud database layer. To slash latency and prevent unnecessary database queries, a cloud-managed Redis instance sits right in front of it. ### Design Decisions: Single Source of Truth & Multi-Tier Caching The core philosophy behind this project was **performance, reusability, and absolute separation of concerns**. Instead of letting the Next.js frontend query the database directly, everything routes through the dedicated Express API. The biggest architectural win here is that **the API acts as a single source of truth for my entire digital footprint.** Beyond the main portfolio at `shubhkumar.in`, I also host my dedicated CV at `cv.shubhkumar.in`. Both frontends consume data from the exact same API endpoints. If I update a project description, add a new tech stack proficiency, or modify my work history, the change reflects universally across all subdomains. To deliver instantaneous, sub-100ms response times globally, the architecture leverages a **two-tier aggressive caching model** : 1. **The API Tier (Redis):** When a request hits the Express backend, it checks the cloud Redis cache first. If it's a hit, it serves it instantly. If it's a miss, it pulls from MongoDB Atlas and hydrates Redis with an expiration TTL (Time-to-Live). 2. **The Frontend Tier (Next.js Data Cache):** Pages aren't just fetching live on every request. Next.js caches data at the framework layer using time-based revalidation (`next: { revalidate: ... }`). This serves prerendered static pages from Vercel’s edge network while quietly updating the data in the background once the timer lapses. ### Hosting & Deployment: The Cloud Setup For hosting, I wanted a fully managed, modern cloud setup that eliminates infrastructure maintenance overhead while providing global scalability. * **Frontend Hosting (Vercel):** The Next.js frontend is deployed on Vercel, providing global CDN distribution and world-class optimization for Next.js assets out of the box. * **Backend Hosting (Render):** The Express.js API runs on Render, managing web environments smoothly with auto-deployments from Git and managed SSL setup. * **Health & Diagnostics (Uptime Monitoring):** To ensure high availability across this distributed setup, I implemented a robust uptime monitoring layer that pings the frontend endpoints and the underlying API services, alerting me the second a bottleneck occurs. ### Mistakes I Made (And How I Fixed Them) No project is built from scratch without a few roadblocks. Here are the major pitfalls I encountered: 1. **The Double-Caching Sync Dilemma:** Layering Next.js revalidation over an aggressive Redis cache meant that content updates were trapped behind two separate timers. Modifying database records sometimes wouldn't show up on the live UI for quite a long time due to cache stacking. * _The Fix (and Current Plan):_ Right now, the site relies on short, balanced time-to-live intervals. However, the long-term solution is already in the works: building a unified dynamic webhook pipeline. When data changes, a hook will trigger an automatic `DEL` command to the Redis key and simultaneously ping a Next.js API route handler to call `revalidatePath()` or `revalidateTag()`, flushing both layers instantly. 1. **Over-Engineering the Backend Initially:** I started treating my personal API like an enterprise microservices platform, worrying about premature optimization before the core features were even stable. * _The Fix:_ I stripped it back to a clean, modular Express architecture. YAGNI (You Aren't Gonna Need It) applies to personal portfolios just as much as production SaaS products. 1. **Handling Cold Starts on Managed Hosting:** When the API instances go quiet, spin-up times on managed cloud infrastructure can sometimes introduce latency for the first visitor. * _The Fix:_ I streamlined database connection pools, minimized the deployment bundle, and utilized the uptime monitoring pings as a dual-purpose "heartbeat" to ensure the API container stays warm, active, and snappy. ### Final Thoughts Building shubhkumar.in from scratch wasn't the fastest way to put a portfolio online, but it was easily the most rewarding. It forced me to think through the entire lifecycle of an application from building a multi-tier cache architecture to managing production cloud deployments. The best part? Because it’s driven by a single-source-of-truth API, it can power any future side project or subdomain I decide to build down the road.

dev.to

Awakari App

awakari.com

CVE-2026-54350 | THREATINT

CVE-2026-54350: Budibase is an open-source low-code platform. Prior to 3.39.12, an unauthenticated visitor of any published Budibase app reads every document of the backing MongoDB, CouchDB, Elasticsearch, DynamoDB-PartiQL, or REST-with-JSON-body collection and, where the buil...

cve.threatint.eu

我的 Vibe Coding 最佳实践——ADR文档

我的 Vibe Coding 最佳实践——ADR文档

blog.est.im

Python Jobs - Вакансии

По размещению: @karrrolina2

t.me

MGLRU Improvement Yielding Nice Gains On Linux 7.2: MongoDB 30~100% Higher Throughput

The many memory management "MM" related improvements were recently merged to Git for the Linux 7.2 kernel. As typical most kernel cycles, some of the low-level improvements can yield nice efficiency wins and better performance in different areas...

phoronix.com

Awakari App

awakari.com

Percona Prioritizes Strategic Partnerships As AI Explodes - Open Source For You

Percona is focusing its network on consultative channel partners to address rising infrastructure costs and data compliance issues caused by rapid Al adoption.

opensourceforu.com

MongoDB Indexes Finally Clicked for Me: Understanding Indexes, Compound Indexes & the Prefix Rule 🚀

While working on a MERN project, I came across these indexes: transactionSchema.index({ user: 1, date: -1 }); transactionSchema.index({ user: 1, type: -1 }); transactionSchema.index({ user: 1, category: -1 }); My first reaction was: > "Why are we creating 3 different indexes for the same schema? Isn't one index enough?" At that time, my understanding was: > "Indexes help MongoDB find records faster." Which is true, but it wasn't enough to explain why multiple indexes existed for the same collection. That simple doubt led me down a rabbit hole of learning about indexes, compound indexes, how MongoDB stores them, and the famous Prefix Rule. Here's what I learned. # What is an Index? Imagine a collection with millions of transactions. db.transactions.find({ user: "Aarthi" }); Without an index, MongoDB may need to inspect every document until it finds the matching records. This is called a **Collection Scan**. Think of it like searching for a chapter in a book without a table of contents. You'd have to flip through page after page until you find it. An index works like a book's table of contents. Instead of scanning every document, MongoDB can jump directly to the relevant records. Example: db.transactions.createIndex({ user: 1 }); Now MongoDB can quickly locate all transactions belonging to a specific user. # What is a Compound Index? A compound index contains multiple fields. Example: db.transactions.createIndex({ user: 1, date: -1 }); This means MongoDB organizes the index by: user └── date Conceptually, it looks something like: Aarthi 2025-08-10 2025-08-09 2025-08-08 John 2025-08-10 2025-08-05 The data is first grouped by `user`, and within each user, it is ordered by `date`. Now queries like: db.transactions.find({ user: "Aarthi" }).sort({ date: -1 }); become very efficient. MongoDB can jump directly to Aarthi's records and retrieve them in date order. # The Prefix Rule: The Concept That Finally Made It Click Consider this index: { user: 1, date: -1 } MongoDB can efficiently use it for: find({ user: "Aarthi" }); ✅ Works find({ user: "Aarthi", date: "2025-08-10" }); ✅ Works But: find({ date: "2025-08-10" }); ❌ Not efficient Why? Because the index is organized by `user` first and then by `date`. MongoDB knows where each user's records start, but it doesn't know where a specific date begins without first navigating through the user groups. This behavior is known as the **Prefix Rule**. A compound index can efficiently support queries that start from the leftmost fields of the index. For example: { user: 1, date: -1, type: 1 } can efficiently support: find({ user }) find({ user, date }) find({ user, date, type }) But not: find({ date }) find({ type }) find({ date, type }) because those queries do not start from the leftmost field. # Back to My Original Doubt I originally saw: transactionSchema.index({ user: 1, date: -1 }); transactionSchema.index({ user: 1, type: -1 }); transactionSchema.index({ user: 1, category: -1 }); Now it makes sense. ### Recent Transactions find({ user }).sort({ date: -1 }); Uses: { user: 1, date: -1 } ### Filter By Transaction Type find({ user, type: "expense" }); Uses: { user: 1, type: -1 } ### Filter By Category find({ user, category: "food" }); Uses: { user: 1, category: -1 } Each index is optimized for a different query pattern. # Another Question I Had: Where Are Indexes Stored? Initially, I thought indexes somehow reorganized the actual documents. But that's not what happens. MongoDB stores documents and indexes separately. Conceptually: Collection ----------- Doc1 Doc2 Doc3 Doc4 And separately: Index(user,date) ---------------- Aarthi -> Doc5 Aarthi -> Doc2 Aarthi -> Doc1 Rosy -> Doc8 Index(user,type) ---------------- Aarthi -> expense -> Doc1 Aarthi -> income -> Doc2 Rosy -> expense -> Doc8 Index(user,category) -------------------- Aarthi -> food -> Doc1 Aarthi -> travel -> Doc2 Rosy -> food -> Doc8 The actual documents remain unchanged. Indexes are separate data structures that contain references to documents. # Then Why Do We Need `.sort()` If the Index Is Already Sorted? This confused me too. Suppose we have: { user: 1, date: -1 } The index itself is sorted. However, MongoDB does not guarantee that results should be returned in date order unless we explicitly request it. For example: db.transactions.find({ user: "Aarthi" }); This may use the index to locate records quickly. But: db.transactions.find({ user: "Aarthi" }).sort({ date: -1 }); tells MongoDB: > "Return these records in descending date order." Since the index is already sorted that way, MongoDB can use the index directly and avoid an expensive in-memory sort. That's one of the biggest performance benefits of compound indexes. # How Does MongoDB Handle Multiple Indexes? This was another question I had. Suppose we have: { user: 1, date: -1 } { user: 1, type: 1 } { user: 1, category: 1 } MongoDB creates three completely separate index structures. Think of them as three separate books: ### Index 1 Aarthi 2025-08-10 2025-08-09 Rosy 2025-08-10 ### Index 2 Aarthi expense income Rosy expense ### Index 3 Aarthi food travel Rosy shopping When a query arrives, MongoDB's query planner decides which index can answer the query most efficiently. Example: find({ user: "Aarthi", type: "expense" }); MongoDB sees: { user: 1, type: 1 } and chooses that index. For: find({ user: "Aarthi" }).sort({ date: -1 }); MongoDB chooses: { user: 1, date: -1 } because it perfectly matches the query. # Why Not Create One Huge Index? I also wondered: { user: 1, date: -1, type: 1, category: 1 } Wouldn't this solve everything? Not really. Because of the Prefix Rule. This index efficiently supports: find({ user }) find({ user, date }) find({ user, date, type }) But: find({ user, category }); is not optimal because `date` and `type` appear before `category` in the index definition. MongoDB cannot efficiently skip the middle fields. That's why index design should follow actual query patterns rather than simply including every field. # The Trade-Off Most Beginners Miss Indexes speed up reads. But they are not free. Every insert, update, or delete must also update all related indexes. For example, when inserting: { user: "Aarthi", date: "2025-08-10", type: "expense", category: "food" } MongoDB must update: Index(user,date) Index(user,type) Index(user,category) every single time. So indexes improve read performance at the cost of: * Additional storage * Slower writes * Extra maintenance This is the classic database trade-off. # My Biggest Takeaway Before this, I thought: > "Indexes make queries faster." Now I think: > "Indexes make specific query patterns faster." Understanding compound indexes, how MongoDB stores them, and the Prefix Rule completely changed the way I think about database design. The best index is not the one with the most fields. The best index is the one that matches the queries your application runs most often. Sometimes a simple question like: > "Why do we have 3 indexes for the same schema?" can lead to understanding an entire database concept. If you've had a similar "aha!" moment while learning databases, I'd love to hear it in the comments.

dev.to

Instruqt Becomes the First and Only Platform to Pair AI-Assisted Content Creation with Native Vertex AI, Amazon Bedrock, and GPU Environments

This new end-to-end AI enablement release enables go-to-market and education teams to build hands-on AI content faster and experience it in real, production-like AI…

financialpost.com