Building a high-performance RESTful API with Drogon and PostgreSQL

Day 100: Back to the MERN/Next.js Stack! After completing my intensive Python series, I'm back on the Next.js 15 Blog Webpage project, which now incorporates advanced backend components! Today was a massive step: revisiting code, setting up core dependencies, and building the essential UI shell. 🛠️ Project Setup and Dependencies I kicked off by installing and configuring the modern stack components: Authentication: Installed the key dependency: npm install better-auth to manage user identity and sessions. Database: Set up my ORM and database driver: npm i drizzle-orm pg dotenv and the dev tools: npm i -D drizzle-kit tsx @types/pg. This confirms my move to PostgreSQL with Drizzle ORM for this project, continuing the relational database focus from my recent microservices work (as referenced in the social media post). 🎨 Core UI and Layout Development I focused on modular, reusable components for the blog's structure: ThemeProvider: Created a wrapper using next-themes to manage dark/light mode, ensuring the entire application (min-h-screen) is contained with a header and footer. Header: Built the navigation bar with a clear Next.js 15 Blog branding, links for Home and Create, and a temporary Login button for authentication. Footer: A simple, sticky footer component to anchor at the bottom of the viewport (sticky top-[100vh]), correctly placed at the end of the flex column in ThemeProvider. AuthLayout: Developed the dedicated login/register page using Shadcn UI Tabs (TabsList, TabsContent) to manage the view for LoginForm and RegisterForm. This foundation is crucial! The structure is clean and ready to integrate the advanced better-auth and Drizzle logic for user authentication and content management. Next Steps: The UI is ready. My immediate next step is to integrate the better-auth client and server logic to make the Login and Register forms fully functional and link them to the PostgreSQL database via Drizzle. #NextJS #TypeScript #DrizzleORM #PostgreSQL #FrontendDevelopment #FullStack #Day100 #LearningInPublic

💭 The Day I Realized My Code Was Too Dependent You might’ve seen people using an ORM directly inside their codebase which honestly makes sense. It removes a lot of overhead and helps you move fast. But that convenience comes with a cost dependency. When your entire backend logic is tightly coupled to an ORM, you’re locked in. And if that open-source library ever drops support or changes direction, you’re suddenly facing a long, painful migration. That’s when I decided to decouple Prisma completely from my core logic. Now my repositories don’t even know Prisma exists everything runs behind adapters and interfaces. If I switch ORM tomorrow, the rest of my codebase stays untouched. Some might argue that doing this in a small project isn’t really necessary and I get that. But here’s how I see it: today it’s a small project, tomorrow it might grow… or maybe it won’t. Either way, that’s the choice you make as an engineer to build with scalability and clarity in mind from day one. Because once a project starts growing, refactoring foundational design decisions becomes 10x harder. Coming from a .NET / C# background, moving to Node.js + Express + PostgreSQL was both tricky and exciting. I brought my OOP mindset with me strong boundaries, clear abstractions, and dependency injection. And yeah, I know frameworks like NestJS already offer these patterns but then again, that introduces another layer of dependency. I wanted my architecture to stand on its own. As Uncle Bob says in Clean Architecture: “Frameworks are tools, not ways of life. Don’t let them dictate your architecture.” That line stuck with me and it’s exactly why I built this way. Because no matter the stack, good architecture and decoupling always pay off. #SoftwareEngineering #CleanArchitecture #BackendDevelopment #NodeJS #PostgreSQL #ExpressJS #CleanCode #DesignPrinciples #SystemDesign #CodeQuality #Engineering #SoftwareDesign

⚡ Codex Build Challenge | Day 10 — Connecting the Dots Between Frontend, Backend & Logic Every day feels like watching the bigger picture of development come together — today was one of those “everything clicks” days. 💡 React ⚛️ Dived deep into Redux, the core of state management in large-scale React apps: • Understood what State, Store, Actions, Reducers, and Slices are • Learned how the Redux lifecycle works — from clicking a button in UI ➡ dispatching an action ➡ updating the store ➡ re-rendering the component • Explored createSelector for optimized state reading LeetCode 💻 • Revisited LeetCode 84 (Largest Rectangle in Histogram) and Maximal Rectangle — mastering stack-based area calculation Database & SQL 💾 • Learned full CRUD — Create, Read, Update, Delete • Explored RDBMS, MySQL basics, and commands like CREATE, USE, and INSERT • Understood signed vs unsigned datatypes and differences between DDL, DML, and TCL commands OOPs in Java ☕ • Started Object-Oriented Programming — understood why we need it • Learned the four pillars of OOP and the difference between abstraction and encapsulation Each topic today felt like a building block — one connecting to another, forming the real foundation of a software engineer. 🧱 #CodexBuildChallenge #React #Redux #MySQL #OOPs #LeetCode #FullStack #DeveloperJourney #Java Tagging: Akshay Saini 🚀, Hitesh Choudhary

I used GraphQL for my project and I want to count some pros of why to use GraphQL over the REST API: - Good data: You get only what you want. It stops the problem of over-fetching (too much data) and under-fetching (not enough) that happens with REST API. It is better for performance. -One endpoint for mutations and queries. It works well when working with microservices. Forget about GET, POST, PUT, DELETE for CRUD operations in REST API. -Working with API is easier here: you control the query and get what you want with one request using nested fields. No need to make many requests like in REST API. -GraphQL and Apollo Client have great IDE for working with queries and mutations, and you can find more info and documentation. -I found error handling also easier than REST APIs, as you get a clear, detailed reason for the error. These are some benefits of GraphQL, but learning GraphQL is a bit harder as there are some concepts like schema, query, mutation types, resolvers, and similar concepts. #GraphQL #RESTAPI #APIDevelopment #WebDevelopment #Microservices #GraphiQL #ApolloClient #SoftwareEngineering #TechTips #APIManagement #Nodejs #NestJs #Typescript #Javascript

How To Connect Your Front-End Project To Back-End data/API. If you are a developer with Node.js + Express and React & you are a beginner then this article gonna very useful for you. Here i breakdown how to connect your front-end project to your back-end database. You can swap these for other tech stacks (Django, Flask, Laravel, Vue, Svelte, etc.) - concepts are the same. 1st step: Create your backend data/list. Always use JSON for data exchange unless you need files. Make sure you understand that where your back-end is set up, i prefer to do it with separate folder like (create-users-management-server), cause it will make our work organized. 2nd step: Test your back-end data by running it on server. In combination of node js and express, run (node server/index.js) or (nodemon). If all is Okay, your back-end setup is done. 3rd step: Now we will work on front-end code, when you fetch data, we might get an error, but no worry, it's for disabled CORS on the back-end, simply enable it by using this (app.use(cors()) ); Then you can see that the err https://lnkd.in/dnwVZijy

🧠 Tried Drizzle ORM with Node.js, and I’m impressed. Been experimenting with Drizzle ORM lately, and honestly, it feels like the ORM TypeScript should’ve had from the start. It’s not trying to hide SQL behind abstractions - instead, it gives you type-safe SQL with full IntelliSense right in your editor. Some standout points: •⚡️ Zero magic - everything is explicit and predictable. •💪 Type-safe queries + schema - compile-time safety across your DB layer. •🧱 Lightweight migrations that actually make sense. •🧩 Works cleanly with Postgres, MySQL, SQLite, Neon, PlanetScale, etc. •🚀 Fits naturally into Next.js / Node.js workflows. If you’ve felt Prisma or Sequelize were too heavy or too abstract, Drizzle feels like a breath of fresh air - simple, fast, and dev-friendly. Might just be my new default ORM for TypeScript projects. #NodeJS #TypeScript #DrizzleORM #Backend #NextJS #WebDev #Postgres #DeveloperTools

🚀 Day 82 #skillupwithgfg & #nationskillup Node.js CRUD Operations Using Mongoose CRUD operations — Create, Read, Update, and Delete — are the backbone of any database-driven application. In Node.js, Mongoose simplifies MongoDB operations by providing an elegant schema-based solution to model data. 1. Create – save() Method The save() method is used to add new documents to a MongoDB collection. It creates an instance of a model and stores it in the database. Example: const user = new User({ name: "Tarun", age: 22 }); user.save(); This inserts a new record in the “users” collection. 2. Read – find() and findById() Methods find() retrieves multiple documents based on a query. If no condition is passed, it fetches all records. User.find({ age: 22 }); findById() fetches a single document using its unique _id. User.findById("652df12a9b..."); 3. Update – updateOne() Method The updateOne() method modifies the first matching document. You can specify conditions and update fields. User.updateOne({ name: "Tarun" }, { $set: { age: 23 } }); It returns an acknowledgment of the update result, not the updated document itself. 4. Delete – deleteOne() Method The deleteOne() method removes the first document that matches the condition. User.deleteOne({ name: "Tarun" }); If the condition matches, the document is permanently deleted from the collection. ✍️ 𝗧𝗮𝗿𝘂𝗻 GeeksforGeeks #NodeJS  #JavaScript #WebDevelopment #Coding #CRUD #FullStack #Developers 📖 More Learning: Full Stack Web Development – Skill Up [https://lnkd.in/dVxtmCEf]

🎯 Backend Project: User Management System with Admin Dashboard (📅 Week 11) This week, I built a complete User Management System using Node.js, Express.js, and MongoDB, featuring user login/signup, CRUD operations, and an admin search functionality. 🧩 What I Focused On: Implementing user registration and login with validation middleware Creating secure session-based authentication for both users and admins Building CRUD operations (add, edit, delete, and view users) Enabling search functionality for admins to manage users efficiently Structuring the project using MVC architecture for scalability and clarity Using Handlebars (hbs) for clean dynamic views 💻 Technologies Used: Node.js – Backend runtime Express.js – Routing and middleware MongoDB – Database for user storage Express-session – Session handling Handlebars (hbs) – Frontend templating engine JavaScript, HTML, CSS – Frontend design basics 🧠 This week’s project gave me hands-on experience in building a real-world multi-role application (User + Admin). It strengthened my understanding of Express middleware, MVC patterns, and data validation with sessions. 👉 Code is available in the comments. Feel free to try it and share your thoughts! #Week11 #Nodejs #Expressjs #MongoDB #UserManagement #BackendDevelopment #CRUD #SessionAuth #AdminDashboard #Middleware #JavaScript #WebApp #LearningByDoing #52WeeksOfLearning #Brototype #BrototypeCalicut #BCK307 #MERNJourney

🚀 New Project: Flask-based Double Opt-in Authentication API I recently built a user authentication API using Flask, implementing a double opt-in verification process — meaning users must confirm their email before accessing the system, ensuring better security and data integrity. The project uses: 🔹 WTForms for form handling and validation 🔹 Flask-Mail for sending dynamic confirmation emails 🔹 A relational database (PostgreSQL/MySQL) for user storage 🔹 A modular architecture, making it easy to scale and maintain For security reasons, I haven’t uploaded the source code publicly since it contains application credentials, but I’d be happy to explain or demonstrate the project privately. This experience helped me deepen my understanding of Flask, user authentication, and secure backend design — key skills I’m developing as I grow as a backend developer. #Flask #Python #API #BackendDevelopment #WebSecurity #LearningJourney

⚡ Backend Devs: Build APIs Faster with devkit-cli Generate FastAPI or Express APIs with CORS, JWT authentication, and support for SQLite, PostgreSQL, MySQL, or MongoDB—all in one command. devkit create --backend-only ✅ Production-ready structure ✅ Containerized with Docker/Podman ✅ Auto-configured .env files Try it: https://lnkd.in/ez7_DJ5M #DevkitCLI #BackendDevelopment #FastAPI #ExpressJS #SoftwareEngineering