Diaa Radwan’s Post

Most people use databases. Very few actually understand what happens behind the scenes. 🤯 This week, I decided to change that. I completed a short course on PostgreSQL Architecture in Amazon Web Services (AWS) 🚀☁️ And here’s what stood out 👇 🔹 How #PostgreSQL actually works internally — WAL writer, sender, receiver, autovacuum, checkpointer 🔹 The role of memory architecture (shared vs local) in performance 🔹 The difference between logical vs physical storage (something we often overlook!) 🔹 How WAL and query processing keep data consistent and reliable 💡 Biggest takeaway: The more you understand the internals, the better you design, debug, and optimize your systems. As someone with a strong database background, revisiting these fundamentals gave me a fresh perspective on building scalable and efficient data solutions. Onwards to going deeper into database internals and cloud-native architectures 🔥 👉 Curious — how many of us really explore what happens under the hood of the tools we use daily? #PostgreSQL #AWS #DataEngineering #DatabaseInternals #TechLearning #ContinuousLearning

I recently wrote about something I use a lot in real projects - MongoDB Aggregation Pipeline. Instead of explaining it in a textbook way, I broke it down using a simple real-world example: Imagine employees going through a pipeline with filters that we can change anytime. That’s exactly how aggregation works. In the article, I’ve covered: What aggregation pipeline really is (simple explanation) How it compares with SQL Why it’s powerful in real systems How we can reuse and modify stages dynamically A real production use case (logs & API monitoring) If you’re working with MongoDB or trying to understand it practically, this might help. Would love to hear your thoughts or how you are using aggregation in your projects. #MongoDB #BackendDevelopment #SoftwareEngineering #DataEngineering #Learning #Tech

🚀 Post #01 | Mastering Kubernetes StatefulSets with Real MySQL Cluster (Hands-On Lab) Most engineers say: 👉 “StatefulSets are used for databases” But very few can actually: ✔ Build a MySQL cluster ✔ Configure replication ✔ Handle persistent storage ✔ Validate real data flow So here’s a complete real-world lab I implemented 👇 🔥 What You Will Learn (Step-by-Step) 1️⃣ Storage Foundation Setup AWS EBS CSI Driver Create StorageClass (dynamic provisioning) 👉 Real persistent storage in Kubernetes 2️⃣ Core Stateful Architecture Headless Service (DNS-based pod discovery) ConfigMap (Master/Slave configs) Secret (secure credentials) 3️⃣ StatefulSet Deployment 2 replicas → mysql-ss-0 (Master) mysql-ss-1 (Slave) Each pod gets its own EBS volume 👉 This is where StatefulSets differ from Deployments 4️⃣ 🔥 Real Challenge (Important) MySQL is NOT automatically clustered You must manually: Configure master log position Setup slave replication Update authentication plugin Sync data correctly 👉 This is where most tutorials stop — but real work starts here 5️⃣ Validation (Proof of Learning) ✔ Created database in master ✔ Verified replication in slave ✔ Restarted pods → data persisted ✔ Storage remained intact 6️⃣ 🚀 Web App Integration Deployed Python Flask App with: User Registration Login System Profile Management Connected to: 👉 Stateful MySQL backend 🧠 Simple Explanation StatefulSet = 👉 “Pods with identity + memory + fixed storage” Even after restart: ✔ Same name ✔ Same data ✔ Same volume ⚠️ Real DevOps Insight If you only know theory → ❌ Not enough If you can: ✔ Build Stateful MySQL ✔ Configure replication ✔ Debug issues 👉 You’re production-ready 📘 Full Lab Guide (Step-by-Step) 👉 🎯 Final Thought Kubernetes is easy to learn… 👉 But hard to master without real labs This lab pushes you from: 👉 “I know Kubernetes” ➡️ “I can run stateful production workloads” 💬 Comment “LAB” and I’ll share more real DevOps scenarios #Kubernetes #DevOps #StatefulSets #AWS #EKS #MySQL #Docker #SRE #CloudComputing #LearnDevOps #HandsOn #TechLearning #DevOpsEngineer

PlanetScale just published a great deep dive on keeping a Postgres queue healthy — how MVCC, dead tuples, and autovacuum can silently degrade your job queue under load. It's a pattern I've implemented with consulting clients many times, and it works well. I do want to add some nuance to how posts like this should be read. It would be easy to walk away thinking Postgres queues are a minefield, but the challenges described here are the kind you hit at scale — and that's true of every infrastructure tool. Redis, RabbitMQ, Kafka — they all have their own version of this post. For most of the early-stage startups I work with, none of this is relevant yet. The biggest benefit of "just use Postgres" is simplicity: one database, one set of operational concerns, one thing to monitor. That's a feature, not a compromise. What PlanetScale is doing to push Postgres into workloads that traditionally required specialized tooling is genuinely impressive, and it makes Postgres an even better starting point — you can go further before you ever need to think about alternatives. But I'd still caution against picking any technology based on its ability to scale indefinitely. The cost of a future migration to something more specialized is almost always less than the velocity you lose by introducing unneeded complexity too early. Of course, take all of this with a grain of salt — every situation is different. But for queueing workloads in particular, the migration path to a more specialized tool is well-trodden. And by the time you actually need it, you'll have a much better understanding of your product's real requirements than you do on day one. Start simple. Postgres can take you further than you think.

🚀 Hands-on with Kubernetes: MySQL + Secret + ConfigMap + Persistent Volume + PersistentVolumeClaim Today I implemented a real-world setup to understand how data persistence works in Kubernetes using MySQL 🔥 💡 Architecture Flow: EC2 (Docker Host) → Kubernetes (kubelet) → MySQL Pod 🔧 Components Used: • Secret → stores MySQL root password securely • ConfigMap → provides default database name • Persistent Volume (PV) → mapped to /mnt/data on host • PersistentVolumeClaim (PVC) → attached to the MySQL Pod 📌 Key Learning: Even if the MySQL Pod is deleted, the data is NOT lost because it is stored on the host (/mnt/data) via a Persistent Volume. 🛠️ Hands-on Validation: 1️⃣ Deployed MySQL using a Kubernetes Deployment 2️⃣ Created databases manually: • CREATE DATABASE MYNEWDB1; • CREATE DATABASE MYNEWDB2; • CREATE DATABASE MYNEWDB3; 3️⃣ Verified data inside Docker host path /mnt/data 4️⃣ Deleted the Pod 5️⃣ Data remained intact ✅ 📊 Conclusion: Kubernetes separates compute (Pods) from storage (Volumes) — enabling stateful and resilient applications. ⚠️ Note: Using hostPath is recommended only for single-node or testing environments, not for production. #Kubernetes #Docker #DevOps #MySQL #PersistentVolume #Cloud #LearningByDoing

We performed an upgrade of MongoDB from 3.x through 7.x over multiple production AWS accounts and it didn't have to be a nightmare. The fear of doing a major database version upgrade that comes with every major version upgrade can be overwhelming, they include: • Loss of data integrity • Breaks in compatibility of schemas and drivers • Moves that take a long time to complete leading to longer downtimes • No confidence in being able to roll back from the upgrade We faced this challenge with over 40 microservices that run on EKS. We tackled the above without sleepless nights. 1. We built a custom Python utility to migrate the data and validate it during the whole process. 2. We built both the old and new environments in parallel until we had 100% confidence in the new environment. 3. We built automated pre- and post-integrity checks to identify and address data drift early. 4. We did a staged rollout of the upgrade across all dev, stage and production environments using automated health checks at each phase. The results were: • Migration time was reduced by approximately 50% compared to the traditional manual process. • Zero data integrity issues were found in the production environment. • No unplanned outages occurred. The biggest lesson learned is that the scariest infrastructure changes will become manageable when you treat the migration itself as software, with automation, testing and rollback processes in place from the very beginning. If your team is delaying a major database upgrade, start with automating your validation layer first. Then work your way up from there! #DevOps #AWS #MongoDB #DatabaseMigration #Kubernetes #EKS #Python #Automation #CloudEngineering #SRE #PlatformEngineering #Infrastructure

Postgres just got a glow-up. A single Postgres server can execute 43,000 durable workflows per second. That’s 3.7 billion workflows per day. No sharding. No external orchestrator. Just plain Postgres + DBOS. Peter Kraft (DBOS, Inc. CTO) just dropped the benchmark everyone’s been asking for: → Raw writes: 144K/sec (12 billion/day) → Direct durable workflows: 43K/sec → Queued workflows (after partitioning): 30.6K/sec The bottleneck? WAL flushing. Everything else (CPU, IOPS) had headroom. Translation: Adding rock-solid durability to your app basically costs you nothing until you’re at ridiculous scale. If you’ve ever been told “Postgres won’t scale for workflows,” this post just proved them wrong. Full benchmark + open-source code here 👇 https://lnkd.in/dMg6NeZa #Postgres #DBOS #Backend #Scaling #Durability #Databases

We're migrating a critical piece of a monolith into microservices. Here's what nobody tells you about running MongoDB and PostgreSQL side by side. 🧵 I've been extracting core modules from a large Node.js monolith into independent services for a construction tech platform. This isn't greenfield — it's surgery on a running system. Here's what I've learned 👇 1️⃣ The hardest part isn't writing new code. It's understanding the old code. Before extracting anything, you need to map how the monolith actually behaves — data flows, implicit dependencies, edge cases that only exist because everything shares one database. Skip this and your microservice will be a broken copy of something you didn't fully understand. 2️⃣ Pick your database based on your data's shape, not on trends. Our monolith runs MongoDB. For the new services we explored PostgreSQL. Why? The data is highly relational — parent-child hierarchies, membership structures, cross-entity references. PostgreSQL gave us referential integrity, JOINs, and stronger transactional guarantees. But it came with trade-offs: schema migrations as a first-class concern, connection pooling tuning for Node.js, and a learning curve for a team used to document databases. 3️⃣ Feature flags are your lifeline. 🚩 We gate every new behavior behind flags. Roll out to a subset of users, compare results, roll back instantly if something breaks. Without flags, a migration is a coin flip. With them, it's a controlled experiment. 4️⃣ Data synchronization is where complexity explodes. 💥 When you extract a module, you don't get a clean cut. We use job queues to sync between systems. Sounds simple until you deal with event ordering, retry logic, and idempotency — each one is a rabbit hole. 5️⃣ "Migrate everything at once" is a fantasy. Extract one bounded context. Validate in production. Iterate. That's how migrations actually ship instead of stalling for years. 📌 Bottom line: this isn't a technical problem — it's a risk management problem. Invest 70% of your time understanding the existing system and 30% building the new one. That ratio feels wrong, but it works. What's your experience with database migrations during microservice extraction? 👇 #SoftwareEngineering #Microservices #NodeJS #PostgreSQL #MongoDB #BackendDevelopment #SystemDesign

“Our DB pod was restarting every 4–5 days… but Grafana showed everything was fine.” 🤔 This happened in our production environment on Kubernetes—and the root cause was not obvious at all. 💡 What we observed: * MySQL (InnoDB) pod restarting periodically * Memory usage looked safe in Grafana * No clear spike or alert 👉 But restarts kept happening 🔍 After deep debugging, here’s what we found: The issue was not “visible memory”…
It was actual memory enforced by the kernel ⚡ Key difference: 📊 Grafana (commonly):
→ Shows working set memory 🧠 Kubernetes (OOM decision):
→ Uses total memory usage (cgroup) 💥 What was happening: * InnoDB buffer pool * Internal DB cache * OS-level page cache 👉 All contributed to total memory ➡️ Container hit memory limit
➡️ OOMKilled
➡️ Pod restarted 🔎 How we verified it: Inside the container: cgroup v1:
/sys/fs/cgroup/memory/memory.usage_in_bytes cgroup v2:
/sys/fs/cgroup/memory.current 👉 This showed the actual memory usage 🔧 Fix:
✔ Tuned InnoDB buffer size
✔ Adjusted memory limits
✔ Aligned monitoring with real metrics 🧠 Big Learning: Not all memory metrics are equal. 👉 What you see ≠ what Kubernetes enforces 🚀 Takeaway:
If your pod restarts “randomly”… Don’t just check dashboards
👉 Check cgroup-level memory Has anyone else faced this kind of hidden memory issue? #DevOps #Kubernetes #Debugging #Production #SRE #Cloud #MySQL

Day 6 of building our URL Shortener 🚀 Today we worked with MongoDB 📊 And this is where things started feeling… real. Because now: We’re not just writing code ❌ We’re actually storing data ✅ Saving URLs, retrieving them, managing records… Big realization: Backend is not just logic. It’s about how you handle data. If your data is not structured well… Your whole system breaks. Learning how data flows = thinking like a real engineer 🧠 Still building. Still improving. 🛠 #BuildInPublic #MongoDB #Database #Backend #WebDevelopment #Learning #SDE