Production Bugs: A Reality of Software Development

🚀 𝐏𝐑𝐎𝐉𝐄𝐂𝐓 #𝟒: 𝐂𝐥𝐨𝐜𝐤𝐢𝐧𝐠 - 𝐓𝐢𝐦𝐞 𝐒𝐞𝐬𝐬𝐢𝐨𝐧 𝐋𝐨𝐠𝐠𝐢𝐧𝐠 (𝐏𝐄𝐑𝐍) For this project, I built Clocking. The inspiration came from a concept we’re all familiar with: The 10,000-Hour Rule. To truly master skills like coding, writing, or trading, we need to put in the hours. In the past, I used standard stopwatches to track my progress, but it was a mess—I had to take screenshots and manually organize them into folders just to know how much time I’d actually spent. I built Clocking to solve this: a dedicated tool to track deep work sessions and visualize progress without the manual clutter. On the backend, I built a robust API using Node.js and Express to persist session data into a PostgreSQL database, allowing users to keep a permanent, organized record of their journey toward mastery. 𝐓𝐡𝐞 𝐕𝐢𝐬𝐢𝐨𝐧 𝐟𝐨𝐫 𝐅𝐮𝐭𝐮𝐫𝐞 𝐈𝐭𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬: I see a lot of potential to take this further—specifically by integrating Computer Vision to verify that a session is actually being worked on. Imagine a dedicated verification system where users can "prove" their deep work through visual check-ins. It would function like Strava, but for skill-building; a platform where people can share their journey with genuine, verified proof of the work they’ve put in. 🛠️ Tech Stack (PERN): PostgreSQL, Express.js, React.js, Node.js, CSS (Modules), and Git for version control. ⚠️ Important Note: This app is currently hosted on Render’s free tier. If it hasn’t been accessed in a while, the server may take 1 to 5 minutes to "wake up" and load the data on your first visit. 🌐 Check out the Live Demo: https://lnkd.in/g5Sae2Cp 📄 GitHub Docs: https://lnkd.in/gykYsXv6 💻 GitHub Profile: https://github.com/Rahelxv #100FullStackProjectsChallenge #WebDevelopment #BuildInPublic #PERNStack #ReactJS #PostgreSQL #FullStackDeveloper #10000HoursRule #Productivity

Tuesday Build Log: When “It Works” Isn’t the Same as “It’s Correct” Yesterday, I tried to share a huge milestone in my 20-week backend mastery journey, but the algorithm had other plans 😅. Let’s try this again! Over the weekend, I pushed my backend skills a bit further. I built a REST API that: → Takes a name input → Calls multiple external APIs (age, gender, nationality prediction) → Processes and classifies the data → Stores everything in PostgreSQL with proper structure → Exposes clean CRUD endpoints Stack: Node.js + TypeScript + Express + PostgreSQL It worked. I got the expected result. But the real story wasn’t the success, it was everything around it. Here’s what stood out: 🔹 Sometimes the bug isn’t your code I spent hours debugging what looked like a backend issue. Turns out it was just poor internet conditions slowing everything down. 🔹 “Fixing it” vs “Fixing it properly” I ran into database connection issues during deployment. I found a workaround that worked instantly… but I know it’s not the final solution. 🔹 Backend development is more than writing logic You’re dealing with infrastructure, environments, networking, and third-party systems all at once. And that’s where things get interesting. Right now, I’m learning that: → A working system doesn’t always mean a correct system → Debugging is as much about elimination as it is about knowledge → Real growth happens when things don’t behave the way you expect Still early in the journey, but things are starting to connect. If you’ve worked with backend systems in production: What’s one issue that looked like a code bug… but wasn’t? #BackendDevelopment #NodeJS #PostgreSQL #BuildInPublic #DevJourney PS: I hope this doesn’t get shadowbanned or something 😅

I just launched my first open-source CLI tool. 🙌 create-samrose-app lets you scaffold a full Next.js stack interactively with a single command. The idea came from a frustration I kept running into: every new project starts with the same setup marathon. ORM config, database setup, auth wiring, CI/CD... before you've written a single feature. So I built the tool I always wanted. $ npx create-samrose-app You pick: • ORM (Prisma, Drizzle, TypeORM, Mongoose) • Database (PostgreSQL, MySQL, SQLite, MongoDB) • Auth (NextAuth, Clerk, JWT) • State (Zustand, Redux, Recoil) • API (tRPC, oRPC, GraphQL, REST) • Testing + extras like Docker & GitHub Actions Everything wired together. Everything production-ready. Building this taught me a ton about CLI design, cross-stack compatibility, and open-source documentation. If you try it, let me know what you think — feedback and contributions are very welcome. And if it saves you even 30 minutes, a ⭐ on GitHub would make my day! 🌐 Docs: https://lnkd.in/gqx_EJgE 📦 npm: https://lnkd.in/g93iKfMg 💻 GitHub: https://lnkd.in/gBiB9yMh #OpenSource #NextJS #CLI #BuildInPublic #DevTools #Package

Leveling Up My TypeScript: Intermediate Concepts for Next.js & PostgreSQL! Hey #TypeScript community! 👋 Just completed a deep dive into crucial intermediate TypeScript concepts. This learning is key for building robust, type-safe applications, especially for my journey with Next.js and PostgreSQL. Here's a quick recap of what I've been mastering: 🔹 Powerful Utility Types: Partial: Making types optional for flexible updates (think API PATCH requests!) Pick<T, K> / Omit<T, K>: Precisely selecting or excluding properties to tailor types (perfect for API requests/responses) Record<K, T>: Defining dynamic key-value objects for configs or lookup tables 🔹 Smart Type Narrowing Techniques: Using typeof, instanceof, in operator, and truthiness checks to tell TypeScript the exact type of a variable at runtime. This eliminates errors and allows for smarter conditional logic. 🔹 Discriminated Unions: A game-changer for handling complex state and actions (like Redux reducers). By using a common 'discriminant' property (e.g., type: "LOADING" | "SUCCESS"), TypeScript intelligently narrows down the specific type, making state management super robust and error-free. These tools are essential for cleaner code, fewer bugs, and efficient development in any modern stack, including Next.js with PostgreSQL. 💬 What's your go-to TypeScript feature that boosts your productivity? Let's connect and share insights! 👇 #TypeScript #NextJS #PostgreSQL #WebDevelopment #Programming #DeveloperLife #TechLearning

Hot take: I've seen engineers spend 2 hours configuring a Docker Compose file just to test a 10-line function. You don't need a full Postgres instance to test a user service. You don't need a Redis container to test a cache layer. You need fast, isolated, reliable tests. That's why I open-sourced @backend-master/test-utils. package- https://lnkd.in/guWmyCRe github- https://lnkd.in/gtx9GYPR Here's what it solves: ❌ Before: Spinning up databases just to test a findOne query ✅ After: MockDatabase with full CRUD in 3 lines of code ❌ Before: Manually building mock HTTP response objects ✅ After: HttpTestBuilder.ok({ userId: 1 }) — done ❌ Before: Hardcoded test data that breaks randomly ✅ After: Fixtures.user(), Fixtures.products(10) — realistic every time ❌ Before: let wasCalled = false; someService.fn = () => { wasCalled = true; } ✅ After: Spy.create() — call count, args, errors, all built-in Built with TypeScript. Zero runtime dependencies. MIT licensed. I'd love feedback from backend engineers — what testing pain point should I tackle next? What should I build next? Drop a comment 👇 → PostgreSQL adapter → GraphQL test utilities → Stream mocking → Event emitter mocks #TypeScript #BackendEngineering #SoftwareTesting #NodeJS #OpenSource #NPM #JavaScript

Ever wondered what happens in the milliseconds after you hit "Enter"? 🚀 Most people see a webpage load instantly, but as developers, we know there’s a high-stakes relay race happening under the hood. From the moment you type a URL to the second the UI renders, your request travels through layers of infrastructure, security, and application logic. Here is the "Life of a Request" in a Django/Nginx stack: The Handshake: It starts with a DNS lookup to find the server, followed by TCP and TLS handshakes to ensure the connection is reliable and encrypted. The Gateway: The Nginx web server acts as the first line of defense, handling the HTTP request and passing it to Gunicorn (WSGI/ASGI). The Django Core: The request hits Middleware (for auth/security), gets routed to the right URL, and lands in a View. The Data Hunt: The ORM translates Python code into a database query, where an Index Scan or Full Scan fetches your data. The Return Trip: A response is created and travels all the way back through the same layers to your browser, which finally renders the UI. It’s a complex journey that happens in the blink of an eye. Understanding this flow is key to debugging performance and building scalable systems. What’s your favorite part of the stack to optimize? Let’s discuss below! 👇 #WebDevelopment #SystemDesign #Django #BackendEngineering #Python #SoftwareArchitecture

Day 38 of the Consistency Journey 🚀 Today was focused on preparing for a Full Stack (MERN + PostgreSQL) interview. ✔ Revised core concepts: • React (state, lifecycle, hooks) • Node.js & Express (APIs, middleware) ✔ Practiced PostgreSQL queries: • SELECT, JOIN, GROUP BY • Basic indexing concepts ✔ Solved a light DSA problem to stay consistent ✔ Practiced explaining: • My project (Chatbot using Next.js + Gemini API) • Problem-solving approach Key Learning: Preparation is not just about solving problems — it’s about adapting based on opportunities and being ready to perform. Current Focus: • Strengthening full-stack fundamentals • Improving communication • Staying consistent with DSA On to Day 39. #FullStack #MERN #PostgreSQL #InterviewPreparation #Consistency #LearningInPublic

Stop building Auth from scratch. 🛑 Every #NestJS developer knows the "Day One" fatigue. You start a fresh project, but before you can touch the actual business logic, you have to spend 3 days setting up: 🔹 JWT strategies & refresh token rotation 🔹 Password hashing & 2FA 🔹 OAuth (Google, GitHub, etc.) 🔹 Database schemas & Docker configs 🔹 Swagger documentation I’ve written this same code in at least 10 different projects. It’s the same 80% every time. So, I built a tool to fix it. 🚀 Introducing @mehdijony/nestjs-user-service Unlike a standard boilerplate, this is a CLI that installs a production-ready User & Auth engine directly into your existing project. Why it’s different: ✅ Smart Detection: It identifies your ORM (Prisma/TypeORM/Mongoose) and package manager (npm/pnpm/yarn/bun) and adapts the code to fit. ✅ Safety First: It creates a restore point before touching a single file. If you don't like the result, run rollback and your project is exactly as it was. ✅ Senior-Grade Features: It includes RBAC, rate limiting, Redis caching, and Event-Driven hooks (Kafka/RabbitMQ) out of the box. I’ve just published a full breakdown of the architecture and how it works on DEV Community. Check out the full article here: 🔗 https://lnkd.in/gfMqvr7w I'd love to hear from other #BackendEngineers—how many times have you re-written your Auth logic? What’s the one feature you always wish was automated? #NodeJS #TypeScript #WebDevelopment #OpenSource #SoftwareEngineering #Backend #Productivity #CodingLife Tips for maximum reach on LinkedIn: Post the Link in the Comments: LinkedIn sometimes limits the reach of posts that lead users off-platform. Post the text, and then immediately add the link as the first comment (or use the "Edit post" trick). Tag People/Groups: If you have colleagues or groups focused on NestJS or Node.js, tag them to start a conversation. Use the Image: Use the "Old Way vs. New Way" image I generated earlier as the media for this post. Visuals of code/terminals perform exceptionally well with the engineering community.

🚀 Day 2 learning NestJS — and things are clicking fast. Today was all about the data layer: TypeORM entities, ConfigModule, and wiring up PostgreSQL. Here's what I built and what I learned: 🗂️ Entities & Relationships Modeled three tables — Users, Products, Reviews — using TypeORM decorators. The relationship structure looks like this: → User has many Products and many Reviews → Product belongs to a User, has many Reviews → Review belongs to both a User and a Product Defining this in pure TypeScript with @OneToMany and @ManyToOne feels far more maintainable than managing foreign keys manually. ⚙️ ConfigModule Used @nestjs/config to load environment-specific .env files (.env.development, .env.production) and inject values through ConfigService. Clean separation of config from code — exactly how it should be in production systems. 🔌 TypeOrmModule.forRootAsync() This is where it all came together. Injecting ConfigService into the TypeORM factory function means the database connection is fully dynamic and environment-aware. One detail worth highlighting: the synchronize flag auto-migrates your schema in dev — incredibly convenient, but something you explicitly turn off in production. #NestJS #TypeORM #PostgreSQL #TypeScript #BackendDevelopment #NodeJS #LearningInPublic #SoftwareEngineering #WebDevelopment #Programming

Leaving Node.js behind: Building a raw HTTP server in Go. After spending the week locking down my PostgreSQL database, it is finally time to build the API server. But moving from Node.js to Go requires a complete mental reset. In Node, you reach for Express.js immediately. You write app.get("/", (req, res) => {}) and you're good to go. In Go? There is no Express by default. You build it raw using the standard library (net/http). This simple block of code completely flips the script on how you handle data. package main import (   "log"   "net/http" ) // The mental shift happens HERE: (w, r) func handler(w http.ResponseWriter, r *http.Request) {   w.Write([]byte("hello world")) } func main() {   http.HandleFunc("/", handler)   if err := http.ListenAndServe(":8080", nil); err != nil {     log.Fatal(err)   } } In Node, it’s always (req, res) - Request first, Response second. In Go, the handler looks like this: (w http.ResponseWriter, r *http.Request). Response first, Request second. Why? Because Go treats the ResponseWriter (w) as a literal tool you are handed to execute your job. The server effectively says: "Here is your pen (w). Now look at the paperwork (r) and write your response back immediately." I'm officially writing my first route to start the Auth sequence. It’s raw, it’s fast, and there’s no framework magic hiding the fundamentals from me. We move! 💪🏾 To the devs who made the switch from JavaScript/Node.js to Go: What was the hardest habit you had to break? Let’s gist in the comments 👇🏾 #Golang #NodeJS #BackendEngineering #API #SoftwareDevelopment #TechBro #TechInNigeria #WeMove