Building Dockerized Multi-Service Application with Node.js and MongoDB

🚀 Built a Microservices-Based Social Media Backend (focused on real-world system design) As a backend-focused engineer, I wanted to go beyond monolithic CRUD apps and understand how scalable systems are actually designed. So I built a microservices-based backend simulating a social media platform — focusing on service decomposition, communication patterns, and scalability. 🔧 What I worked on: • Designed & implemented API Gateway (JWT auth, routing, rate limiting) • Built independent services: Auth, Posts, Media, Search • Implemented event-driven architecture using RabbitMQ • Used Redis for caching & rate limiting • Integrated Cloudinary for media handling • Containerized services using Docker ⚙️ Key backend concepts applied: • Service-to-service communication (sync + async) • Event-driven workflows (post.created, post.deleted) • Eventual consistency across services • Decoupled architecture with independent scaling potential • Gateway as a centralized security layer 🧠 Challenges & Problem Solving: • Deciding when to use synchronous vs asynchronous communication • Maintaining data consistency across services • Structuring clear service boundaries • Handling multiple infrastructure components together (MongoDB, Redis, RabbitMQ) 📌 What this demonstrates: • Strong understanding of backend architecture & system design fundamentals • Ability to build and manage distributed systems • Hands-on experience with Node.js ecosystem & real-world backend tooling Github Link :- https://lnkd.in/d_PxhQn6 #OpenToWork #BackendDeveloper #NodeJS #Microservices #SystemDesign #SoftwareEngineering #Redis #RabbitMQ #MongoDB

𝗖𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝘀 𝗮𝗿𝗲 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝗮𝗯𝗼𝘂𝘁 𝗽𝗮𝗰𝗸𝗮𝗴𝗶𝗻𝗴 𝗰𝗼𝗱𝗲. 𝗖𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝘀 𝗮𝗿𝗲 𝗮𝗯𝗼𝘂𝘁 𝗰𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗶𝗻𝗴 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲. We went through a real - world deployment using Podman: • React UI (served by NGINX) • Spring Boot API • PostgreSQL database 𝙄𝙩 𝙬𝙖𝙨 𝙖𝙡𝙡 𝙖𝙗𝙤𝙪𝙩 𝙪𝙣𝙙𝙚𝙧𝙨𝙩𝙖𝙣𝙙𝙞𝙣𝙜 𝙝𝙤𝙬 𝙨𝙮𝙨𝙩𝙚𝙢𝙨 𝙖𝙧𝙚 𝙙𝙚𝙨𝙞𝙜𝙣𝙚𝙙. Design components to understand: • The frontend should never talk directly to the database • The API acts as a controlled gateway between networks • Networking is not connectivity - it is security architecture • Multi-stage builds remove unnecessary code and reduce attach surface • Containers are ephemeral - but data must persist The basic request flow is: 𝗨𝘀𝗲𝗿 --> 𝗨𝗜 --> 𝗔𝗣𝗜 --> 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲 But underneath that flow is: • Network isolation controlling who can talk to whom • DNS-based service discovery removing dependency on IPs • Persistent storage ensuring data survives container restarts • Optimized images reducing size and attack surface It's not just DevOps. It's about how systems are designed and operated. #SoftwareArchitecture #DevOps #CloudComputing

What is actually running behind ZenSpend. People see the ZenSpend UI and ask about the design. What I want to talk about is what is running underneath it. The frontend is Next.js, served through CloudFront via S3. Behind that, two Node.js microservices, one handling authentication, one handling transaction logic. They run as separate pods on an EKS cluster, deployed across three availability zones. If one zone goes down, the app keeps running. That is not an accident, that is the architecture working the way it was designed to. Each service lives in a private subnet. The database — RDS PostgreSQL 15 — lives in a separate database subnet with no public IP address. The only thing that can reach it is the EKS worker node security group. Not the VPC CIDR, not some broad rule. Specifically the node group. That is the difference between infrastructure that is convenient and infrastructure that is secure. The deployment pipeline runs on GitHub Actions. Every commit triggers a lint check, the test suite, and a Trivy container scan before anything gets pushed to ECR. ArgoCD watches the repo and syncs the cluster automatically when a new image lands. No manual kubectl apply. No SSH into a server at 2am wondering what is different. The GitOps model means the cluster state is always exactly what the repo says it should be. The Dockerfiles are multi-stage builds. The builder stage handles npm installs including all the dev dependencies. The runtime stage copies only what is needed to run, no Nodemon, no dev tooling, and no unnecessary packages. Image sizes dropped by over 80% compared to single-stage builds. Smaller images mean faster pod starts and a smaller attack surface. The observability layer has Prometheus scraping metrics from every pod, Grafana tracking SLOs, and ELK centralizing logs across all three services. When something breaks, and something always breaks eventually, there is a trail. This is what it takes to run a real product seriously. Not because it is a unicorn startup. Because the habits you build on small systems are the ones that carry you to big ones. Full architecture diagram below. #DevSecOps #Kubernetes #EKS #Terraform #Docker #Microservices #AWS #CloudArchitecture #ZenSpend

🚀 Update: DevOps Memory Assistant (Building in Public) Quick progress update on my project 👇 After setting up the backend and database, I’ve now added: 🔍 Search functionality Now the tool can: ✅ Store DevOps issues (error, cause, fix) ✅ Retrieve past issues instantly using search Example: Facing "CrashLoopBackOff" again? → Just search and get your previous solution instead of debugging from scratch. Tech used: Go (Backend) PostgreSQL (Database) Next I’m planning: AI-based suggestions for similar errors Simple UI (frontend) CLI tool for faster usage This project is helping me understand backend systems much deeper. Would love feedback or suggestions 🙌 🔗 GitHub: https://lnkd.in/dPdtvmgv #DevOps #Kubernetes #Golang #BuildInPublic #LearningInPublic

🚀 Docker Basics Every Developer Should Know (Containers, Images, Volumes, Networks) If you're building modern applications, Docker is no longer optional — it’s essential. Let’s break down the core concepts in a simple way 👇 📦 Container (Runtime) A container is a lightweight, runnable instance of your application. Think of it as: Your app + its dependencies + environment Example: You package your .NET API inside a container and run it anywhere — local, server, or cloud. * Runs consistently across environments * Fast startup * Isolated from other apps 🧱 Image (Blueprint) An image is a read-only template used to create containers. Think of it as: Snapshot of your app Example Dockerfile: #dockerfile FROM https://lnkd.in/gDd_5qgK COPY . /app WORKDIR /app ENTRYPOINT ["dotnet", "MyApp.dll"] * Reusable * Version controlled * Easy to share via Docker Hub 💾 Volume (Persistent Storage) Containers are temporary — data inside them can be lost. Volumes solve this problem. Store data outside the container Example: #bash docker run -v mydata:/app/data myapp * Data persists even if container is deleted * Ideal for databases, logs, uploads 🌐 Network (Communication) Docker networks allow containers to talk to each other. Example: API container talks to DB container Microservices communicate internally #bash docker network create mynetwork * Secure communication * Service-to-service connectivity * Works great for microservices 🔥 Why Use Docker in Real Projects? Without Docker: * Works on my machine problem * Environment mismatch (Dev vs QA vs Prod) * Manual setup headaches With Docker: * Same environment everywhere * Easy onboarding (just run container) * Faster deployments * Better scalability (microservices ready) * CI/CD friendly * Isolation between services 💡 Real Example You build a .NET API + SQL Server: * One container for API * One container for DB * Connected via Docker network * DB data stored in volume Now your entire system runs with a single command If you're not using Docker yet, you're making your life harder than it needs to be. What’s your experience with Docker in real projects? #docker #devops #dotnet #microservices #cloudcomputing #softwarearchitecture #backenddevelopment

Just finished building a production-grade microservices backend from scratch in Go. → GraphQL API Gateway — single entry point for all client requests → Account, Catalog & Order microservices — each with its own PostgreSQL database → gRPC for internal service communication (typed contracts via Protocol Buffers) → Docker Compose to wire the whole thing together Some decisions I'm proud of: • The Order service snapshots product prices at purchase time — so historical orders stay accurate even if catalog prices change later • Every service follows a clean Repository → Service → gRPC Server layering. Zero business logic leaks into the transport layer. • Each service is independently deployable with its own DB — true microservices, not a distributed monolith What's coming next: ⚙️ CI pipeline with GitHub Actions 📋 Structured JSON logging with zerolog ☸️ Local Kubernetes deployment with kind Still a lot to build, but the foundation is solid. Happy to connect with anyone working on distributed systems or backend architecture. Implementation: https://lnkd.in/gBPagWve #Golang #Microservices #gRPC #GraphQL #Docker #BackendDevelopment #SoftwareEngineering

Spring Boot DAY 19 – REST API Basics What is a REST API? 👇 A REST API (Representational State Transfer) is a way for applications to communicate over the internet using HTTP protocols. It follows simple principles: ✔ Uses standard HTTP methods ✔ Stateless communication (each request is independent) ✔ Data is usually exchanged in JSON format 🔹 Common HTTP Methods 🔸 GET → Retrieve data from the server 🔸 POST → Create new data 🔸 PUT → Update existing data 🔸 DELETE → Remove data Example: If you have an Employee system: GET /employees → Fetch all employees POST /employees → Add new employee PUT /employees/1 → Update employee with ID 1 DELETE /employees/1 → Delete employee with ID 1 🚀 Why REST APIs are Important? REST APIs are the backbone of modern applications: ✔ Web Applications ✔ Mobile Applications ✔ Microservices Architecture ✔ Third-party Integrations With Spring Boot, creating REST APIs becomes easy using annotations like: @RestController @RequestMapping @GetMapping @PostMapping Spring Boot handles: ✔ JSON conversion automatically ✔ Dependency injection ✔ Embedded server setup 💡 In simple words: REST API = Bridge between frontend and backend. hashtag#RESTAPI hashtag#SpringBoot hashtag#BackendDeveloper hashtag#JavaDeveloper hashtag#Microservices hashtag#WebDevelopment

🚀 Exciting news for developers and enterprise teams! AWS Transform is now available in Kiro and VS Code! As someone who uses Kiro daily for code assistance, architecture reviews, and rapid prototyping, this is a game-changer. Now you can kick off large-scale migrations and modernizations right from your IDE — no context switching, no manual handoffs. Here's what makes this launch powerful: 🔧 Crush tech debt at scale — Java, Python, Node.js version upgrades, AWS SDK migrations (boto2→boto3, Java SDK v1→v2, JS SDK v2→v3), and more 🔁 Run transformations across thousands of repositories at once 🌐 Seamless continuity — start a job in your IDE, track it in the web console, finish wherever it makes sense — job state and context shared across every surface 🛠️ Build your own custom transformations — define your own playbooks beyond the AWS-managed ones AWS Transform is compressing enterprise transformation timelines from years to months — and now it's available right where developers already work. If you're using Kiro or VS Code, install the AWS Transform Power (Kiro) or the AWS Transform extension (VS Code) and start transforming today! 🔗 https://lnkd.in/e8e-QRZD #AWS #AWSTransform #Kiro #VSCode #CloudMigration #Modernization #GenAI #DevTools #TechDebt #AWSome

🚀 Day 81 – Docker Compose Basics Today I explored Docker Compose, a powerful tool that helps run and manage multiple containers together using a single configuration file. 🐳 When applications grow, they often need multiple services like Node.js, databases, and caching systems. Docker Compose makes it easier to manage them all at once. 🔹 What I Learned Today ✔ What is Docker Compose? Docker Compose allows you to define and run multi-container applications using a simple YAML file. ✔ docker-compose.yml File This file describes the services, networks, and volumes required for an application. ✔ Running Multiple Containers Instead of starting containers manually, Docker Compose can start everything with a single command. ✔ Service Communication Containers can communicate with each other easily through Docker networks. 🔹 Example Scenario A typical full-stack application may include: 💻 Node.js Backend 🗄️ Database (MongoDB / MySQL) ⚡ Cache (Redis) With Docker Compose, all these services can be started together with one command. 🔹 Why This Matters Docker Compose helps developers: ✅ Manage multi-container applications ✅ Simplify development environments ✅ Run complete projects easily ✅ Improve deployment workflow Learning this brings me one step closer to real-world DevOps and scalable application deployment 🚀 #100DaysOfCode #Docker #DockerCompose #DevOps #BackendDevelopment #SoftwareEngineering #LearningJourney

Every project I worked on needed file storage. And every time, the setup was either rushed, poorly abstracted, or tightly coupled to a specific provider. So I took the time to build a boilerplate that I'd actually want to inherit on a new project. 📦 MinIO + NestJS + Prisma — Production-Ready Boilerplate https://lnkd.in/dMEUEBcB The decisions I'm most proud of: ✅ IStorageService interface — business logic is completely decoupled from storage implementation. Switching from MinIO to AWS S3 is a config change, not a refactor. ✅ Pre-signed URLs — clients upload and download directly to MinIO, the backend just orchestrates. No wasted bandwidth, scales cleanly. ✅ File lifecycle via Prisma — every file has a tracked state (PENDING → UPLOADED → FAILED). Query your storage metadata with SQL. ✅ Security from the start — Helmet headers, sanitized storage keys, validated DTOs, Joi env schema that fails fast with clear messages. ✅ Zero friction to run — one Docker Compose command spins up PostgreSQL, MinIO, and pgAdmin. Built with TypeScript strict, layered architecture, and dependency inversion — the way I believe backend code should be written. 🔗 https://lnkd.in/dMEUEBcB #OpenSource #NestJS #TypeScript #BackendDevelopment #SoftwareEngineering #NodeJS #MinIO #AWS #Prisma #CleanArchitecture