Containerizing Node.js with Dockerfile and Docker Compose

🚀 Shipped a production-grade URL Shortener — from code to AWS in one push. Not just another "Hello World" API. This one's fully containerised, auto-deployed, and live on AWS right now. 🔗 Live demo → https://lnkd.in/gnxQwDJN ⚙️ GitHub → https://lnkd.in/gaASvhAE --- Here's what the stack looks like under the hood: ⚡ Spring Boot 3 + Java 21 — REST API with two clean endpoints: shorten a URL and redirect via slug 🗄️ PostgreSQL — Stores every slug-to-URL mapping with optional expiry timestamps 🔴 Redis (cache-aside pattern) — Every redirect checks Redis first. Cache hit = sub-millisecond response. Cache miss = PostgreSQL fallback + re-cache. No cache invalidation headaches. 🐳 Docker + Docker Compose — Three containers (app, Postgres, Redis) with health-check-gated startup. The app only starts after both dependencies pass their health checks. Zero race conditions. 🔁 GitHub Actions CI/CD — Every push to main triggers: → Unit tests (JUnit 5 + Mockito) — must pass to continue → Multi-stage Docker image build → Trivy vulnerability scan (CVE check before anything ships) → Push to AWS ECR (tagged with commit SHA) → Rolling deploy to AWS ECS Fargate → Wait for deployment stability ☁️ AWS ECS Fargate — Serverless containers sitting behind an Application Load Balancer, inside a custom VPC with properly scoped security groups. IAM least-privilege throughout. 🎨 Frontend — Pure HTML/CSS/JS with a dark dev aesthetic, deployed on Vercel. History persisted in localStorage, one-click copy, live API indicator. #Java #SpringBoot #AWS #Docker #DevOps #CICD #Redis #PostgreSQL #BackendDevelopment #SoftwareEngineering #CloudComputing #ECS #GitHubActions #SystemDesign #OpenToWork #BuildInPublic #JavaDeveloper #BackendEngineering #SoftwareArchitecture #TechCareers #WebDevelopment #Microservices #SDE

New tutorial on Foojay! Ricardo Mello shows you how to build a search feature for Airbnb listings using Spring Boot, MongoDB, and the Kotlin Sync Driver. The article walks through setting up your project, connecting to MongoDB Atlas, and implementing search functionality with practical code examples. Perfect if you're working with Kotlin and want to learn more about MongoDB's search capabilities. https://lnkd.in/eSjkeYaR #Kotlin #SpringBoot #MongoDB #Java #Backend

The common approach for background tasks in Django typically involves using Redis and Celery. However, it's important to remember that defaults are habits, not strict requirements. In a recent Django API project, a different solution was implemented by using Postgres as the task queue, utilizing a concurrency primitive known as SELECT FOR UPDATE SKIP LOCKED—something many developers overlook. This approach features: - A single table for the queue - Atomic job claims by workers - Built-in retries, scheduling, and concurrency control As a result, the docker-compose setup was simplified from four services to just two. Is this method suitable for every project? Not necessarily. However, for many Django applications focused on I/O-bound background tasks, it proves to be more than adequate. The entire journey was documented, detailing the reasons, methods, and scenarios where this approach may not be ideal. Read more here: https://lnkd.in/dyhwBQaU

Deploying a Full-Stack Production App to AWS (The Complete Flow) 🌐 Are you tired of "it works on my machine" but fails in the cloud? I’ve mapped out the entire end-to-end journey of deploying a React + Django + MySQL stack using professional DevOps standards. 🏗️ This isn't just a deployment—it's a production-grade ecosystem. Here is the full breakdown of what it takes to go live in 2026: 🛠️ Phase 1: The Foundation (Dockerization) Before the cloud, we containerize. We ensure the app runs the same everywhere. Frontend & Backend Dockerizing: Wrapping React and Django into isolated environments. Docker Compose: Orchestrating the Frontend, Backend, and MySQL database to talk to each other locally. 📦 Phase 2: The Shipping Yard (AWS ECR) We don't just "upload" code; we ship images. AWS CLI Setup: Authenticating your local machine with Amazon. Elastic Container Registry (ECR): Creating private warehouses to store our versioned Docker images. Tag & Push: Pushing our local "packages" to the AWS cloud. ☁️ Phase 3: The Infrastructure (AWS EC2) Setting up our digital home in the sky. Instance Launch: Spinning up the server and securing it with PEM keys (SSH). IAM Roles: Giving our server "permission" to pull images from the ECR warehouse securely without hardcoding passwords. Migrations: Running Django database migrations in the live environment. 🤖 Phase 4: The Automation (CI/CD Pipeline) The secret sauce to high-performing teams. GitHub Actions: Setting up the "Robot Team." Now, every time you push code to GitHub, the system automatically builds, tags, and deploys the new version to AWS. Zero manual work. 🛡️ Phase 5: The Professional Polish (Networking & Security) Turning an IP address into a trusted brand. Route 53: Mapping your custom domain (e.g., theproductpeek.shop). AWS Certificate Manager: Issuing SSL/TLS certificates for that green padlock 🔒 (HTTPS). Application Load Balancer (ALB): The ultimate traffic cop. It handles security, manages SSL, and ensures your app stays fast and responsive. 💡 The Big Picture By the end of this flow, you aren't just a "coder"—you are an Architect. You understand how data flows, how security protects users, and how automation saves time. Which part of the AWS stack do you find the most challenging? Let's troubleshoot in the comments! 👇 #AWS #FullStack #Django #ReactJS #Docker #DevOps #CloudComputing #SoftwareEngineering #CICD #SystemDesign

3 weeks ago, I didn’t even know what 𝐀𝐏𝐈 𝐆𝐚𝐭𝐞𝐰𝐚𝐲 was. Today, I shipped a fully serverless URL shortener on AWS , built with Mohan Merugu. 🚀☁️ And honestly? This project taught me more than any course ever could. Here's how it actually went: 𝐖𝐞𝐞𝐤 1 — "How hard can it be?" We set up DynamoDB, wrote the Lambda functions in Python, connected everything to API Gateway. It worked. We felt like geniuses. 𝐖𝐞𝐞𝐤 2 — Reality check. CORS errors. IAM permission issues. CloudFront cache not refreshing. The kind of bugs that don't make sense until suddenly they do. 𝐖𝐞𝐞𝐤 3 — It clicked. Everything connected. User pastes a URL → Lambda shortens it → DynamoDB stores it → short link redirects perfectly. Zero servers managed. What we shipped: ⚙️ lambda_shorten.py — generates a 6-char short code + writes to DynamoDB 🔁 lambda_redirect.py — fetches the URL and returns HTTP 302 redirect 🌍 S3 + CloudFront frontend — fast UI, HTTPS, globally accessible 🔐 iam_policy.json — strict least-privilege access (security-first) This is project #2 in my cloud journey (Azure was #1). Each one teaches something the docs never tell you. 📂 The full repo is public on GitHub. Every file — Lambda functions, IAM policy, frontend, README — is open for anyone who wants to learn how a real cloud project is structured. If you're just starting out, use it. That's exactly why we made it public. 🔗 https://lnkd.in/d7a6dMvm #AWS #Serverless #CloudComputing #BuildInPublic #OpenSource #Lambda #Python #StudentDeveloper #hackerhaibhai

💥 I made a small mistake in Kubernetes… and it broke everything. While deploying MongoDB + Mongo Express on Kubernetes, I hit a scary error: 👉 CreateContainerConfigError At first, I thought something was wrong with my containers, YAML, or even Minikube setup. But the real issue? ❌ Just ONE mismatched name. I used: mongo-secret But actually created: mongodb-secret That’s it. One tiny inconsistency = entire app fails. 👉 What I learned from this: • Kubernetes is VERY strict about naming • Secrets & ConfigMaps must match EXACTLY • kubectl describe pod is your best debugging weapon 👉 After fixing it, everything worked perfectly: ✔ MongoDB connected ✔ Mongo Express UI running ✔ Services communicating via internal DNS If you're learning Kubernetes, don’t just watch tutorials — 👉 build real projects and break things. That’s where real learning happens. 📖 I wrote a full step-by-step guide here: https://lnkd.in/gVCzAhHs 💻 Full source code: https://lnkd.in/g3vgsvQh #Kubernetes #DevOps #MongoDB #CloudNative #Backend #LearningInPublic #100DaysOfCode

Bun 1.3 just deleted 47 npm packages from my package.json — and dropped my Lambda cold start from 2.1s to 380ms. [ Bun 1.3 — The Dependency Massacre Cheat Sheet ] What got killed in one runtime upgrade: → better-sqlite3 → bun:sqlite (3-6x faster) → ioredis → Bun.redis (~2.5x throughput, built on hiredis) → @aws-sdk/client-s3 → Bun.s3 (zero-config, native presigned URLs) → dotenv → native .env loader → ws → built-in WebSocket server → node-fetch → native fetch → vitest → built-in test runner (3x faster cold runs) → vite → routes-based fullstack dev server The numbers that matter: AWS Lambda arm64, 512MB. Swapped @aws-sdk/client-s3 (14MB unzipped, 280+ transitive deps) for Bun.s3. Cold start: 2.1s → 380ms. An 82% drop. Why? The SDK's transitive deps never get parsed. They never existed. bun install on a clean Next.js starter: 2.1s. npm install: 53s. That's 25x. node:* compatibility now passes 95%+ of the Node test suite. The migration friction that killed Deno enterprise adoption? Gone. But here's the senior-engineer test: bun:sqlite uses a custom C binding that bypasses sqlite3_open_v2 VFS hooks. Which means LiteFS and Litestream silently break. If you're running multi-region SQLite on Fly.io and you migrate without checking your replication layer, your writes will look fine in dev and quietly diverge in prod. Fall back to better-sqlite3 for those workloads, or move to Turso/libSQL. The real story isn't speed. It's that every Solution Architect defending a 200-dependency Node service to security and FinOps just got a one-line answer: rip them out. Supply-chain risk, cold start tax, CVE surface — all of it collapses when SQLite, Redis, S3, env, and WebSockets are runtime primitives instead of community packages maintained by 3 people on weekends. Native isn't free. But it's a lot cheaper than the audit you're failing right now. If you found this helpful, repost — it might save someone a 3am incident. #Bun #NodeJS #JavaScript #SolutionArchitect #DevOps

🚨 As systems grow, backend challenges grow faster. Something I’ve observed while working on real-world applications 👇 Everything works fine at the start… Then usage increases 📈 And suddenly: ❌ APIs slow down ❌ Database queries become heavy ❌ Unexpected production issues ❌ Fixing one issue affects another This usually comes down to backend design decisions. What has helped me handle this better 👇 ✅ Keeping API structure clean (Controller → Service → DB) ✅ Writing optimized MongoDB queries with proper indexing ✅ Using caching (Redis) to reduce repeated load ✅ Moving heavy tasks to background jobs ✅ Adding basic monitoring & logging Small improvements early can prevent big problems later. Still learning and improving every day 🚀 Curious — what backend challenges are you facing these days? #Nodejs #BackendDevelopment #MongoDB #DevOps #SoftwareEngineering #ScalableSystems #LearningInPublic

For years, the AWS Lambda Handler Cookbook was missing one thing I kept putting off: real, production-grade CRUD across multiple functions with a single, unified Swagger. v9.6.0 finally fixes that, thanks to the event handler alpha feature in Powertools for AWS Lambda's event handler. What's new in v9.6.0: 🔧 Create, get, and delete order APIs as micro Lambda functions over DynamoDB 📄 Unified OpenAPI schema generated across all endpoints 🔍 Automated API breaking changes detection in CI 📑 Swagger published to GitHub Pages and always in sync with the code What you get overall in the cookbook template: 🏗️ Production-ready serverless project in Python with CDK infrastructure 🧪 Five testing strategies: unit, integration, infrastructure, security, and E2E ⚙️ CI/CD with GitHub Actions across dev, staging, and production environments 📊 CloudWatch dashboards and alarms with SNS notifications out of the box 🔒 WAF protection, input validation with Pydantic, and idempotent API design 🏷️ Feature flags and dynamic configuration via AppConfig 📈 Business KPI metrics and distributed tracing with Powertools for AWS Lambda Thanks to Leandro Cavalcante Damascena for developing the Powertools OpenAPI feature that enabled the unified schema. I hope you merge it soon :) 🔗 https://lnkd.in/dZe74TCc #AWSLambda #Serverless #AWS #OpenAPI #PowertoolsForAWS #PlatformEngineering

The environment your code runs in is just as important as the code itself. Most developers learn this the hard way a deployment breaks, a teammate can't reproduce a bug, a server behaves differently from localhost. Then they find Docker. Then everything makes sense. Here is the clear breakdown every developer needs to bridge the gap between writing code and shipping systems Docker: The Single Unit Docker packages your application and everything it needs — libraries, dependencies, configurations into a single Image. When you run that image, it becomes a Container. That container is completely isolated from the host machine. It runs exactly the same way on your laptop, a staging server, or a production cloud environment. The "it works on my machine" problem disappears. You're not shipping code anymore. You're shipping the environment. Use Docker when: → You're packaging a single service (e.g., a Python API) → You're defining that environment in a Dockerfile → You're pushing a single artifact to a container registry for CI/CD Docker Compose: The Orchestrator Real systems are rarely just one service. They're an ecosystem an API, a database, a cache, a background worker, maybe a frontend. You could start five containers manually and try to wire their networks by hand. Nobody actually does that. Docker Compose lets you define your entire stack in one compose.yaml file. One command brings it all up: the internal network is configured, storage volumes are mounted, and every service starts in the correct order. docker compose up That's your whole environment. Use Docker Compose when: → Your project needs multiple services to function (e.g., FastAPI + PostgreSQL + Redis) → You want a new teammate running the full stack in under 60 seconds → You need shared networking and data persistence between containers ——— For context on where this is going in 2026: A single compose.yaml can now deploy directly to Google Cloud Run or Azure. It can spin up a local LLM alongside your API. It can generate Kubernetes manifests when you're ready to scale. You start local. The same file follows you to production. ——— Building without containerization leads to configuration drift, fragile deployments, and environments nobody can reproduce. Docker and Docker Compose aren't advanced tools you graduate into. They're the baseline for shipping software that survives in the real world. The earlier you treat them that way, the cleaner everything downstream becomes. What's your current setup; fully containerized, halfway there, or still putting it off? #Docker #DockerCompose #SoftwareEngineering #machinelearning #DevOps #SystemArchitecture #BuildInPublic