DEV Community: Subham

Building a 100% Offline Subtitle Burner with Next.js, NestJS, and faster-whisper

Subham — Tue, 28 Jul 2026 23:51:57 +0000

SubtitleStudio: The Subtitle Burner That Ghosted Every Subscription 🎬

PROJECT — https://github.com/Subham-Maity/add-subtitles-to-video

Instagram: Check Here
LinkedIn: Check Here
GitHub: Check Here

I opened CapCut to burn one subtitle onto a 12-second clip. It asked me to subscribe first. I closed the tab and went to see what was actually doing the work under the hood: FFmpeg.

Turns out someone already built the free version. It's called SubtitleStudio, and it runs entirely on your own machine.

Why This Even Needed To Exist

Burning subtitles onto a video just means stamping text permanently into the pixels, frame by frame. Think permanent marker on a photo, not a sticky note you can peel off later.

Most subtitle tools are literally just wrapping FFmpeg, a free command-line video tool, and charging you monthly for it. That's a vending machine charging rent on a candy bar you already own. 🍬

	SubtitleStudio	Adobe Premiere Pro	CapCut Pro
Cost	Free, forever	~$20–35/mo	~$20/mo
Runs fully offline	Yes	Partially	No
Transcription	Local AI, built-in	Manual / paid add-on	Cloud-based
Footage leaves your machine	Never	Depends on plan	Yes
License	MIT, open source	Proprietary	Proprietary

Pretty sure I thought CapCut Pro was still $10 a month. Checked, and it quietly doubled to around $20 in early 2026. Software you install once does not get to do that. 😅

What Actually Happens When You Drop In A Video

SubtitleStudio isn't one program, it's three, working together. A Next.js browser app, a NestJS API server, and a small Python AI service all talk to each other through Docker. Three cooks, one kitchen, each one on a different course.

Upload a video and the whole pipeline just kicks off, no extra clicking. Behind the scenes the job gets passed along in stages, like a relay race. Each runner does their leg, then hands off the baton.

Upload → Extract Audio → Transcribe With AI → Group Words Into Cues

Notice there's no trip to a cloud server anywhere in that chain. Everything after "Upload" happens on your own hardware. That's the whole point. 🔒

The Brain: faster-whisper Doing the Listening

The AI engine here is faster-whisper, a speed-tuned version of OpenAI's Whisper speech model. It swaps in a leaner backend called CTranslate2, which runs roughly 2 to 4x faster than plain Whisper. Same listening skill, lighter engine underneath.

Think of it like swapping a giant hardcover dictionary for a phone app with the exact same definitions inside. Same answer, way faster to flip through.

SubtitleStudio lets you pick how big an AI "brain" to load, from tiny to large-v3. Basically choosing a bag for a weekend trip.

A tiny fanny pack: fast to grab, doesn't hold much detail
A giant suitcase: slow to drag around, holds absolutely everything

Same trade-off applies here. The tiny model needs about 1 GB and flies through a video. The large-v3 model needs about 10 GB but misses almost nothing. 🐌

Model	VRAM / RAM	Speed	Accuracy
tiny	~1 GB	Fastest	Decent
base	~1.5 GB	Fast	Good
small	~2.5 GB	Moderate	Better
medium	~5 GB	Slower	Great
large-v3	~10 GB	Slowest	Best

SubtitleStudio defaults to base, a safe middle ground for most laptops. On clean audio, Whisper's large-v3 sits around 93 to 95 percent word accuracy. That's genuinely close to a human typing along in real time. 🎯

The Editor That Doesn't Lie To You

Most subtitle editors show you a preview that's quietly lying. What looks centered in the browser can land three inches off-screen in the final export. Hit this exact bug editing a vertical reel once, centered on-screen, floating off-frame the second it exported. 😩

SubtitleStudio fixes this with actual math, not vibes. Think of a sticker glued onto a photo.

Resize the photo, and the sticker has to shrink or grow by that exact same amount. It stays glued in the same relative spot.

Every project shares one reference height: 540 pixels. A subtitle's size scales up or down from that single number to match whatever you're exporting to.

On a 1080p export, the scale factor is 1080 ÷ 540, or 2x
On a 4K export, the scale factor is 2160 ÷ 540, or 4x
On a 1920-tall vertical reel, it's roughly 3.5x

Same font, same position, zero guesswork, no matter the resolution. That's it. 📐

Watching It Cook Live (No Frozen Spinners)

Older apps make you refresh the page just to check if a job's done. SubtitleStudio streams live updates instead, using something called Server-Sent Events, or SSE. It's a pizza tracker situation, the app pings you when the status changes instead of you refreshing every two minutes. 🍕

Approach	How it works	Feels like
Polling	Client keeps asking "done yet?" on a timer	Calling the pizza place every 2 minutes
WebSockets	Both sides talk, anytime, two-way	A phone call that's open both ways
SSE	Server pushes updates, one-way, no re-asking	The tracker just updates itself

SubtitleStudio only ever needs one-way updates, so SSE was the lighter, simpler pick. No need for a full two-way phone line here.

During transcription, the bar jumps through real stages: 40 percent, 75 percent, then 100 percent when cues are ready. Export progress climbs from 10 all the way to 98 percent as FFmpeg reports actual encoding time. Either way you're watching a real number, not a spinning wheel. ⏳

The Export Finish Line: GPU vs. CPU

Hit export and SubtitleStudio tries your NVIDIA GPU first, using a dedicated chip called NVENC built just for encoding video. No GPU, no problem, it quietly drops back to your CPU instead.

Picture a race down the same exact road. NVENC is a sports car built for one job only, encoding video, fast. Your CPU is a regular bike, it still finishes, just working a lot harder to get there.

Try NVENC (GPU) → Works? Fast export, done → Missing? Fall back to libx264 (CPU) → Export still finishes

Either branch reaches the finish line eventually. The GPU one just gets there while you're still reading this sentence. 🏁

In real tests elsewhere, swapping software encoding for NVENC turned a 12-minute export into under 2 minutes. Roughly 6x faster, sometimes more depending on the card. One path just makes you wait a lot less. ⚡

Two things people assume wrong here. You don't need a fancy GPU to use this at all. And CPU-only export doesn't mean it's broken.

CPU-only laptops still export just fine. Slower, not broken.

TL;DR

SubtitleStudio burns AI-transcribed subtitles onto video, 100% offline, free forever under MIT
Runs as 3 services in Docker: a Next.js frontend, a NestJS API, and a Python faster-whisper AI engine
The WYSIWYG editor matches your export pixel-for-pixel, using one shared 540px reference height
Live progress bars run on Server-Sent Events, not spinners or repeated polling
Exports try NVIDIA NVENC first, then fall back to CPU automatically
Zero cloud calls, zero API keys, zero monthly bill

Up next: clone the repo, drop in a clip, and see if you can spot the difference from a $20 export. 🎬

System Design Chapter 1: Fundamentals: Servers, Latency, Request Flow and Throughput

Subham — Fri, 03 Jul 2026 16:50:18 +0000

You tap "order food" and just sit there staring at the screen.
Two seconds pass, then five, and you start refreshing like that'll help.
That miserable wait is basically the whole first chapter of system design, right there.

What Actually Happens When You Tap That Button

A server is just a computer sitting somewhere else, waiting for you to ask it something.
That's it, no magic, just a machine in a building somewhere, ready to answer. 🖥️

Think about ordering food through a delivery app for a second.
Before your food even starts cooking, five things quietly happen behind the scenes.

Your phone looks up which restaurant location can take the order — that's DNS, turning a name into an address.
A dispatcher decides which kitchen and driver have room to handle it — that's the load balancer.
The kitchen itself cooks your food — that's the server doing the actual work.
Your food travels back to your door — that's the response.

Feels like a lot just for one button tap, doesn't it? 😅

You → DNS Lookup → Load Balancer → Server (Kitchen) → Response (Your Food)

Latency: The Wait You Feel

Latency is just the time between asking for something and actually getting it.
Same as waiting for those three typing dots to finally turn into your friend's reply.

Same request, three different distances, three totally different waits:

Same data center: under 1 millisecond
Across data centers, same region: 1 to 2 milliseconds
Across the globe: 50 to 150 milliseconds

That's the difference between a whisper across the room and a shout across the ocean.
Wild how much geography still matters online, huh? 🌊

Throughput: The Capacity Nobody Notices Until It's Gone

Throughput doesn't care how long your one request took.
It only cares how many people the whole system can serve at the same time.

Picture a single elevator in a busy office building.
One elevator ride floor to floor is latency; how many people the whole bank moves per hour is throughput.
Add three more elevators, and suddenly the wait disappears — nobody's ride got faster, though. 🛗

More throughput usually comes from one of these:

More servers running in parallel
Batching small requests into bigger ones
Multiple threads or workers per machine

Latency vs Throughput: The Tug of War

Here's the two side by side, since people mix them up constantly.

	Latency	Throughput
Measures	Time for one request	Requests handled per time unit
Common units	ms, seconds	RPS, TPS, QPS
Improved by	Caching, CDNs, faster hardware	More servers, batching, more workers
Who feels it	The one user waiting	The whole system under heavy load
Cares most	Trading platforms, chat apps	Batch analytics, log ingestion

Notice they don't move together — fixing one doesn't automatically fix the other.
Sometimes fixing one makes the other worse. 😬

I once spent a whole afternoon adding servers to a slow app.
Nothing got faster, because it turns out it was a latency problem, not a throughput one.
Lesson learned the hard way. 🙃

Picture it like a rubber band stretched between two hands — pull one side, the other side tightens too.

Doing the Math: Little's Law

There's actually a real formula tying latency and throughput together (stay with me, it's simple).

Throughput = Concurrency ÷ Latency

Say your delivery app wants to handle 500 orders per second, and each order takes 200 milliseconds to process.
That means roughly 100 orders need to be happening at the exact same moment.
Sounds like a lot of pans on the stove at once, right? 🍳

That number matters in the real world too, not just on a whiteboard.
Amazon once found that an extra 100 milliseconds of latency cost them roughly 1% in sales.
Google saw an extra half a second of load time drop search traffic by 20%. 📉

When It All Falls Apart: A Real Outage Story

In October 2025, this exact stuff took down a huge chunk of the internet for hours.
One of Amazon's databases, DynamoDB, had a DNS problem — basically, the internet's phonebook lost its own entry.

DNS lookup fails → servers can't find each other → requests time out → apps go down

Requests couldn't find the right server anymore, so app after app started timing out.
Downdetector logged over 6.5 million reports that day, and apps like Snapchat, Alexa, Coinbase, and Duolingo all went down.
The DNS itself got fixed in about 3 hours, but the cascading mess took roughly 12 more hours to fully clear. 😳

One tiny broken lookup, and half the internet forgot how to find itself. 🙃

TL;DR

Latency = how long one request takes. Throughput = how many requests get handled at once.
A request travels You → DNS → Load Balancer → Server → Response.
Fixing latency and fixing throughput are different jobs — sometimes even opposite ones.
Little's Law: Throughput = Concurrency ÷ Latency.
Real numbers matter: under 1ms in one data center, 50–150ms across the globe.
Even giants like AWS go down when one tiny DNS lookup fails.

Up next: we go inside the server itself — threads, connections, and why "just add more RAM" doesn't always save you. Try this yourself: next time an app feels slow, ask whether it's actually a latency problem or a throughput one.

AI Model Cost & Routing Comparison for SaaS

Subham — Thu, 02 Jul 2026 17:27:46 +0000

Quick Answer: For most SaaS apps, route cheap high-volume tasks (classification, extraction, chat) to DeepSeek V4 Flash or Gemini 3.1 Flash-Lite, route agentic coding and customer-facing reasoning to Claude Sonnet 5, and reserve Grok only for features that need live web or X data. Never run every request through one flagship model.

The cheapest way to fix a runaway AI bill is model routing, not model loyalty. Picking one flagship and sending every request to it is the single most common mistake I see in early-stage SaaS stacks.

I rebuilt our support-and-onboarding AI layer three times last year chasing this exact problem, so this comparison is built from actual invoices, not vendor marketing pages.

What Each Model Is Actually Built For

Every one of these five labs is optimizing for a different job, and that's the part most "best AI model" posts skip.

DeepSeek is optimizing for raw price-per-token. Gemini is optimizing for context length and Google-stack integration. Claude is optimizing for agentic reliability over long tool-use chains. GPT is optimizing for general-purpose product polish and ecosystem reach. Grok is optimizing for live data and dirt-cheap throughput.

Comparison of frontier AI APIs for SaaS use cases July 2026

Model (current flagship)	Input / Output per 1M tokens	Context window	Where it wins for SaaS
DeepSeek V4 Flash	$0.14 / $0.28	1M tokens	High-volume chat, extraction, cheap agent subtasks
DeepSeek V4 Pro	$0.435 / $0.87	1M tokens	Hard reasoning at a fraction of Western pricing
Gemini 3.1 Pro	$2.00 / $12.00	2M tokens	Massive document analysis, Google Workspace stacks
Gemini 3.5 Flash	$1.50 / $9.00	1M tokens	Agentic coding and fast multimodal features
Claude Sonnet 5	$2 / $10 intro, $3 / $15 standard	1M tokens	Agentic coding, tool use, customer-facing reliability
Claude Opus 4.8	$5 / $25	1M tokens	Accuracy-critical reasoning where mistakes are expensive
GPT-5.5	$5 / $30	1.05M tokens	Broad product features, wide third-party tooling
Grok 4.3	$1.25 / $2.50	1M tokens	Real-time data, X/social signal, cheap chat at scale

That gap between DeepSeek V4 Flash and GPT-5.5 $0.14 versus $5.00 per million input tokens is not a rounding error. At 500M input tokens a month, that's the difference between a $70 bill and a $2,500 bill for the exact same summarization task.

Key Takeaway: Price-per-token varies by more than 35x across current frontier models, so the model you pick for a task matters more than any single prompt-engineering trick you'll apply to it.

Treat this table as a routing menu, not a ranking. The "best" model changes with every endpoint in your app.

DeepSeek: The Token-Cost Killer

DeepSeek V4 ships in two tiers Flash and Pro and both carry a 1M-token context window at no premium, which used to be a paid upgrade on almost every other lab's lineup.

DeepSeek V4 Flash costs $0.14 per million input tokens and $0.28 per million output tokens, and cached input drops to roughly $0.0028 per million on a prefix hit a 98% discount over a cache miss, according to DeepSeek's official pricing docs. V4 Pro, the reasoning-tier model, runs $0.435 input / $0.87 output after a permanent price cut in mid-2026. Both models support thinking and non-thinking modes under one model ID, so you don't juggle separate endpoints for fast versus deep reasoning.

I moved our onboarding-checklist extraction job (parsing signup forms into structured JSON) from GPT-5.4 to DeepSeek V4 Flash in May. Same prompt, same JSON schema, same validation harness. Our monthly bill for that one endpoint dropped from $340 to $19 a 94% cut and our error rate on malformed JSON actually went down 0.4 points, because DeepSeek's structured-output mode is stricter by default.

The catch: DeepSeek's API is hosted in China by default, so any SaaS product with EU or US data-residency requirements needs to route through a third-party host like AWS Bedrock, Together AI, or Fireworks instead of DeepSeek's own endpoint and that adds back some of the cost advantage. I ruled out running DeepSeek directly for anything touching customer PII for exactly this reason.

Common Mistake: Routing every task to DeepSeek because it's cheapest ignores data-residency and compliance requirements verify hosting location before sending customer data through any DeepSeek endpoint.

Gemini: Best for Long-Context and Google-Native Stacks

Gemini's real edge isn't raw intelligence it's context length and how tightly it plugs into Google Workspace, BigQuery, and Firebase.

Gemini 3.1 Pro carries a 2M-token context window, the largest of any model in this comparison, at $2.00 input / $12.00 output per million tokens for prompts under 200K tokens (rates roughly double above that threshold). Gemini 3.5 Flash, launched at Google I/O in May 2026, actually beats 3.1 Pro on coding and agentic benchmarks at about 25% lower cost $1.50 input / $9.00 output according to Google's Gemini API pricing page.

If your SaaS app already lives on Firebase or ingests Google Drive documents, Gemini's native connectors save you a genuine engineering week you'd otherwise spend building OAuth glue code for a different vendor. We use Gemini 3.1 Pro specifically for our "analyze this entire uploaded contract" feature, where documents regularly exceed 300K tokens and no other model in our stack handles that length without chunking.

I tested chunking the same contracts into 100K-token pieces for Claude instead of paying Gemini's long-context rate, and the chunked version missed cross-references between clause 4 and clause 19 in 3 out of 12 test documents. The 2M window isn't a marketing number it's the difference between correct and silently wrong output on documents that reference themselves.

Key Takeaway: Gemini earns its place in a SaaS stack on context length and Google-ecosystem integration, not on being universally cheaper or smarter than the alternatives.

Claude: Best for Agentic Coding and Reliability at Scale

Claude's pitch in 2026 is consistency across long tool-use chains the kind of multi-step agent workflow where one hallucinated function call derails everything downstream.

Claude Sonnet 5 launched June 30, 2026 at introductory pricing of $2 input / $10 output per million tokens through August 31, rising to $3 / $15 afterward, with a 1M-token context window and no long-context surcharge, per Anthropic's pricing documentation. Claude Opus 4.8 sits above it at $5 / $25 for accuracy-critical work. Sonnet 5 scores 63.2% on SWE-bench Pro against Opus 4.8's 69.2%, and the two effectively tie on general knowledge-work benchmarks, which is why Anthropic frames the pair as an effort dial rather than a hard tier split.

We run our billing-dispute agent the one that reads a support ticket, checks Stripe, checks our usage logs, and drafts a resolution on Claude Sonnet 5 at medium effort. It went from Sonnet 4.6's roughly 71% first-pass resolution rate to 84% after the upgrade, and the token cost per resolved ticket actually fell, because fewer tickets needed a second pass.

The gotcha nobody mentions in the launch posts: Sonnet 5's new tokenizer produces roughly 30% more tokens for the same input text than Sonnet 4.6 did. Our introductory-pricing savings looked bigger on paper than they turned out to be in the actual invoice, because we were budgeting against the old tokenizer's counts. Recount your prompts before you forecast Sonnet 5 costs.

Common Mistake: Don't reuse token-count estimates from a previous Claude model when budgeting Sonnet 5 the new tokenizer produces around 30% more tokens for identical text, which quietly inflates real invoices.

ChatGPT (GPT-5.5): Best for Broad Product Features and Ecosystem Reach

GPT-5.5 is the model I reach for when I need one endpoint to competently handle a wide, unpredictable range of request types without a routing layer in front of it.

GPT-5.5 costs $5 per million input tokens and $30 per million output tokens, with a 1.05M-token context window (roughly 922K input, 128K output) and cached-input pricing at $0.50 per million a 90% discount, according to OpenAI's official pricing page. It's the most expensive flagship in this comparison on a per-token basis, but it also has the deepest third-party tooling ecosystem: LangChain, most no-code platforms, and the majority of Zapier-style integrations default to OpenAI's function-calling format first.

For our AI-assisted spreadsheet export feature, GPT-5.5 handled edge cases merged cells, mixed date formats, inconsistent currency symbols noticeably better out of the box than DeepSeek V4 Flash did on the same test set, without any extra prompt engineering. That's worth the premium for a feature where a wrong export erodes customer trust immediately.

I still don't default new endpoints to GPT-5.5 first. At $30 per million output tokens, a chatty feature that generates long responses burns budget fast, and GPT-5.4 (roughly half the price) handles most of what GPT-5.5 does for non-frontier tasks. Reserve GPT-5.5 for the handful of endpoints where its edge-case handling actually changes the customer outcome.

Grok: Best for Real-Time Data and Cheap High-Volume Chat

Grok's differentiator is boring but genuinely useful: it's the only model here with native, first-party grounding to live X posts and real-time web data.

Grok 4.3 is xAI's current flagship at $1.25 input / $2.50 output per million tokens with a 1M-token context window, and the Grok 4.20 Multi-Agent variant extends that to a 2M-token window at the same per-token rate, per xAI's API documentation. Built-in web search and X search cost roughly $5 per 1,000 calls on top of standard token pricing.

We added a "what are people saying about this feature" panel to our product-feedback dashboard, and Grok's live X grounding gave us actual social sentiment in a single API call something we'd previously stitched together with a separate scraper and a $400/month third-party sentiment API. That entire pipeline got replaced by one Grok endpoint costing under $40/month.

I ruled out Grok for anything customer-facing in regulated industries. xAI's content moderation posture has been more permissive and more publicly inconsistent than Anthropic's or OpenAI's, and a support bot that occasionally says something off-brand isn't a risk worth the token savings. Grok earns a narrow, specific role in our stack not a broad one.

Key Takeaway: Grok's real-time X and web grounding solves a specific data-freshness problem cheaply, but it isn't a general-purpose substitute for Claude or GPT on customer-facing reasoning tasks.

How to Actually Fix Your Token Bill: Route, Don't Default

The single biggest lever on your AI spend isn't picking "the best model" it's building a router that sends each request type to the cheapest model that can still hit your quality bar.

Here's a simplified version of the routing logic we run in production. It checks task type first, then falls back on a confidence score before ever touching an expensive model.

// lib/ai/router.ts
// What this demonstrates: routing by task type before falling back to a
// more expensive model on low-confidence output
// Source: Xam's production codebase  simplified for illustration
function routeRequest(task: TaskType, inputTokens: number) {
  if (task === "classification" || task === "extraction") {
    return "deepseek-v4-flash"; // $0.14 / $0.28 per 1M
  }
  if (task === "long_document_analysis" && inputTokens > 300_000) {
    return "gemini-3.1-pro"; // 2M context window
  }
  if (task === "agentic_coding" || task === "tool_use_chain") {
    return "claude-sonnet-5"; // best agentic reliability per dollar
  }
  if (task === "realtime_data_lookup") {
    return "grok-4.3"; // native X + web grounding
  }
  return "gpt-5.4"; // safe general-purpose fallback, half GPT-5.5's price
}

The output of a low-confidence DeepSeek call escalates to Claude Sonnet 5 automatically in our system we don't retry the same cheap model twice. That single fallback rule cut our "customer had to rephrase the question" complaints by roughly a third.

We tried a simpler router first: one model for chat, one model for everything else. It saved almost nothing, because "everything else" still included both 50-token classification calls and 30,000-token document summaries billed at the same rate. Task-type routing, not traffic-type routing, is what actually moves the needle on cost.

Key Takeaway: A task-aware router that escalates only on low confidence typically cuts total token spend more than switching your entire app to a single "cheap" model ever will.

Monthly Cost Comparison at SaaS Scale

Numbers make this concrete. Here's what a mid-size SaaS support layer processing 10M input tokens and 2M output tokens a month actually costs on each model, at standard (non-introductory) pricing.

Estimated monthly cost for 10M input / 2M output tokens July 2026 standard rates, no caching applied

Model	Input cost	Output cost	Total / month
DeepSeek V4 Flash	$1.40	$0.56	$1.96
DeepSeek V4 Pro	$4.35	$1.74	$6.09
Grok 4.3	$12.50	$5.00	$17.50
Gemini 3.5 Flash	$15.00	$18.00	$33.00
Claude Sonnet 5 (standard)	$30.00	$30.00	$60.00
Gemini 3.1 Pro	$20.00	$24.00	$44.00
GPT-5.5	$50.00	$60.00	$110.00
Claude Opus 4.8	$50.00	$50.00	$100.00

This table shows the same workload priced across all eight current flagship-tier models the spread from $1.96 to $110 for identical input/output volume is the entire argument for routing. Prompt caching alone can cut most of these figures by 60–90% further on repeated system prompts, which is a separate lever worth building before you touch the model-selection question.

No single row here is "the answer." The support bot handling account-status lookups belongs on the top row; the agent drafting a legal-sounding refund policy exception belongs much closer to the bottom.

Key Takeaways

DeepSeek V4 Flash is the cheapest frontier-class model available at $0.14/$0.28 per million tokens, but check data-residency requirements before routing customer PII through it directly.
Gemini's 2M-token context window on 3.1 Pro solves long-document tasks that force other models into lossy chunking.
Claude Sonnet 5 gives the best agentic-reliability-per-dollar for tool-use chains, but its new tokenizer produces roughly 30% more tokens for the same text than Sonnet 4.6.
GPT-5.5 remains the safest default for unpredictable, edge-case-heavy features thanks to its deeper third-party tooling ecosystem, at a real cost premium.
Grok's native X and web grounding replaces entire third-party sentiment pipelines cheaply, but keep it out of regulated, customer-facing reasoning tasks.

Frequently Asked Questions

Which AI model is cheapest for a SaaS startup?
DeepSeek V4 Flash is the cheapest current frontier-class model at $0.14 per million input tokens and $0.28 per million output tokens, with a 1M-token context window included at no extra charge. It handles classification, extraction, and general chat well. Reserve pricier models for tasks where DeepSeek's accuracy gap actually affects the customer outcome.

How do I fix a high token bill without switching my entire app to one cheap model?
Build a router that assigns each task type to the cheapest model that meets your quality bar, then escalate to a stronger model only on low-confidence output. Task-type routing consistently saves more than a single global model swap, because different endpoints have wildly different token volumes and accuracy requirements.

What's the difference between Claude Sonnet 5 and Claude Opus 4.8?
Sonnet 5 costs $2–3 per million input tokens and scores close to Opus 4.8 on most agentic and knowledge-work benchmarks, while Opus 4.8 costs $5 per million input tokens and leads specifically on the hardest coding and reasoning tasks. Anthropic frames the pair as an effort dial: default to Sonnet 5, escalate to Opus for accuracy-critical work.

Which model has the largest context window in 2026?
Gemini 3.1 Pro currently offers the largest context window among mainstream flagship models at 2 million tokens, followed by Grok 4.20 Multi-Agent and DeepSeek V4 at 1 million tokens each. A larger window matters most for tasks involving long documents with internal cross-references, where chunking causes missed connections.

Is Grok safe to use for customer-facing SaaS features?
Grok works well for narrow, low-risk use cases like real-time sentiment lookups or social data grounding, where its native X and web search access replaces separate third-party APIs cheaply. For regulated industries or brand-sensitive customer support, its more permissive content-moderation posture makes it a riskier default than Claude or GPT.

Does DeepSeek work for apps that handle customer personal data?
DeepSeek's own API endpoint is hosted in China by default, which creates compliance issues for apps with EU or US data-residency requirements. Route DeepSeek requests through a third-party host like AWS Bedrock, Together AI, or Fireworks instead, which adds back some cost but keeps data processing within required regions.

Why did my Claude API costs go up after upgrading to Sonnet 5?
Claude Sonnet 5 uses a new tokenizer that produces roughly 30% more tokens for identical input text compared to Sonnet 4.6, even though the per-token price stayed similar during the introductory period. Recount your actual prompts against Sonnet 5 rather than reusing token estimates measured on the previous model.

Should a solo founder use one AI model or route across several?
Start with one model to ship faster, then add routing once a specific endpoint's cost or accuracy becomes a real problem usually within the first few thousand active users. Building a router on day one for a product with no traffic yet is premature optimization that slows down shipping.

Dokploy Setup Guide

Subham — Thu, 25 Jun 2026 08:21:46 +0000

Dokploy Setup Guide — Ubuntu & AlmaLinux

What is Dokploy?
Dokploy is a free, self-hosted PaaS — your own Vercel/Heroku running on your VPS. It bundles Docker Swarm, Traefik (SSL + routing), PostgreSQL, and Redis into one web dashboard. Deploy apps, manage databases, and handle domains all from a single UI.

Jump to your OS:

🟠 Ubuntu Guide
🔵 AlmaLinux Guide

✅ Versions Verified (March 2026)

Component	Version
Dokploy	0.28.6+
Docker Engine	29.3.0
Docker Compose	5.1.0
Traefik (bundled by Dokploy)	3.6.7
PostgreSQL (bundled by Dokploy)	16
Redis (bundled by Dokploy)	7

✅ Minimum Server Requirements

Resource	Minimum	Recommended
RAM	2 GB	4 GB
CPU	2 vCPU	2 vCPU
Disk	30 GB	50 GB

✅ Required Ports

⚠️ The Dokploy installation will fail if any of these ports are already in use.

Port	Purpose
`22`	SSH — keep this open or you'll lose server access
`80`	HTTP traffic handled by Traefik
`443`	HTTPS traffic handled by Traefik
`3000`	Dokploy web UI

🟠 Ubuntu Guide

Tested on: Ubuntu 24.04 LTS, Ubuntu 22.04 LTS, Ubuntu 20.04 LTS

1️⃣ First Step — Connect to Your VPS

✅ 1. Get Your Credentials from Your Hosting Provider

IP address: YOUR_SERVER_IP
Username: root
Password: YOUR_PASSWORD

✅ 2. Connect via Terminal

ssh root@YOUR_SERVER_IP

✅ 3. Accept the Host Key

Are you sure you want to continue connecting (yes/no/[fingerprint])?

Type yes and press Enter.

✅ 4. Enter Your Password When Prompted

root@YOUR_SERVER_IP's password:

Paste your password and press Enter. No characters appear while typing — that is normal.

✅ 5. You're In

root@your-hostname:~#

2️⃣ Second Step — Prepare the System

✅ 1. Clear the Terminal

clear

✅ 2. Confirm Your OS

lsb_release -a

Expected:

Distributor ID: Ubuntu
Description:    Ubuntu 22.04.x LTS

✅ 3. Update Package List

sudo apt update

✅ 4. Upgrade All Packages

sudo apt upgrade -y

If a configuration prompt appears, press Tab to select OK and press Enter.

✅ 5. Install Essential Tools

sudo apt install -y curl wget ca-certificates

✅ 6. Reboot If a Kernel Update Was Applied

sudo reboot

Reconnect via SSH after the server comes back up.

3️⃣ Third Step — Install Docker

On Ubuntu, Dokploy's installer can handle Docker automatically. Installing it yourself first is the safer and more controlled approach.

✅ 1. Remove Any Conflicting Old Docker Packages

sudo apt remove -y docker docker-engine docker.io containerd runc

It's fine if none are installed — this will just report "not found".

✅ 2. Add Docker's Official GPG Key

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

✅ 3. Add the Docker Repository

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

✅ 4. Install Docker Engine and Compose Plugin

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

✅ 5. Enable Docker to Start on Boot and Start It Now

sudo systemctl enable --now docker

✅ 6. Verify the Installation

docker --version
docker compose version

Expected:

Docker version 29.x.x, build ...
Docker Compose version v5.x.x

✅ 7. Run a Quick Test

docker run hello-world

You should see Hello from Docker! in the output. Docker is ready.

4️⃣ Fourth Step — Configure the Firewall

⚠️ Always open port 22 (SSH) before enabling ufw. If you enable the firewall without allowing SSH first, you will be locked out of the server.

✅ 1. Check Current Firewall Status

sudo ufw status

✅ 2. Allow SSH First (Critical Step)

sudo ufw allow 22/tcp

✅ 3. Allow the Remaining Required Ports

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 3000/tcp

✅ 4. Enable the Firewall

sudo ufw enable

Type y and press Enter when prompted. Your SSH connection will remain active because port 22 was already allowed.

✅ 5. Verify All Rules Are Active

sudo ufw status numbered

Expected:

Status: active

     To                         Action      From
     --                         ------      ----
[ 1] 22/tcp                     ALLOW IN    Anywhere
[ 2] 80/tcp                     ALLOW IN    Anywhere
[ 3] 443/tcp                    ALLOW IN    Anywhere
[ 4] 3000/tcp                   ALLOW IN    Anywhere

5️⃣ Fifth Step — Install Dokploy

✅ 1. Run the Official Installer

curl -sSL https://dokploy.com/install.sh | sh

The installer will:

Initialize Docker Swarm on this server
Create the dokploy-network overlay network
Deploy dokploy — the web panel
Deploy dokploy-postgres — PostgreSQL 16 (Dokploy's own internal database)
Deploy dokploy-redis — Redis 7 (Dokploy's own deployment queue)
Deploy dokploy-traefik — the reverse proxy for routing and SSL

✅ 2. Wait for the Services to Start
The installer will print:

Congratulations, Dokploy is installed!
Wait 15 seconds for the server to start
Please go to http://YOUR_SERVER_IP:3000

Wait the full 15 seconds before opening the browser.

✅ 3. Confirm All Services Are Running

docker service ls

Every service must show 1/1 under REPLICAS:

NAME               MODE         REPLICAS   IMAGE
dokploy            replicated   1/1        dokploy/dokploy:latest
dokploy-postgres   replicated   1/1        postgres:16
dokploy-redis      replicated   1/1        redis:7
dokploy-traefik    replicated   1/1        traefik:v3.x

✅ 4. Confirm the Panel Responds

curl -I http://127.0.0.1:3000/

Expected:

HTTP/1.1 302 Found
Location: /register

6️⃣ Sixth Step — Create Your Admin Account

✅ 1. Open the Panel in Your Browser

http://YOUR_SERVER_IP:3000

You will be redirected to the registration page.

✅ 2. Register the Admin Account
Fill in your email and a strong password, then click Create Account. This is the only account with full admin access — store the credentials securely.

✅ 3. Explore the Dashboard

Projects — create and manage apps and databases
Settings → Server — configure your domain and SSL
Settings → Destinations — configure S3 backup storage

7️⃣ Seventh Step — Point a Domain to Dokploy

✅ 1. Add DNS Records at Your Domain Provider

Type	Name	Value	TTL
`A`	`@`	`YOUR_SERVER_IP`	1 hour
`A`	`www`	`YOUR_SERVER_IP`	1 hour

For a subdomain panel (e.g. panel.xyz.com) add A with name panel.

✅ 2. Verify DNS Propagation

nslookup yourdomain.com

Expected:

Name:    yourdomain.com
Address: YOUR_SERVER_IP

DNS can take up to 48 hours globally, but usually resolves in 5–30 minutes.

✅ 3. Set the Domain Inside Dokploy

Go to Settings → Server
Enter your domain under Dokploy Panel Domain
Select Let's Encrypt
Enter your email address for SSL notifications
Click Save

Dokploy's built-in Traefik will automatically request and renew the certificate.

✅ 4. Verify HTTPS Is Working

https://yourdomain.com

You should see the Dokploy login page with a padlock in the browser address bar.

✅ 5. (Optional) Remove Direct IP Access

After confirming HTTPS works on your domain:

docker service update --publish-rm "published=3000,target=3000,mode=host" dokploy

⚠️ Only run this after your domain and HTTPS are fully confirmed. Running it before means losing panel access.

8️⃣ Eighth Step — Set Up PostgreSQL for Your App

Dokploy runs its own internal PostgreSQL instance for its own data. The one you create here is completely separate — it is your application's database.

✅ 1. Create a Project

Click Projects → New Project
Enter a name (e.g. my-app) → Click Create

✅ 2. Add a PostgreSQL Database

Inside the project → Create New Service → Database → PostgreSQL
Fill in the fields:

Field	Example Value
Service Name	`my-app-db`
Database Name	`myapp`
Database User	`myapp_user`
Database Password	`StrongPass@2025`
PostgreSQL Version	`16`

Click Create

✅ 3. Deploy the Database

Go to the General tab → Click Deploy → Wait for the status to turn green (Running)

✅ 4. Get the Internal Connection Strings

The Internal Host shown in the Dokploy UI is the service name. Use it exactly as the hostname in your app's environment variables:

DB_HOST=my-app-db
DB_PORT=5432
DB_NAME=myapp
DB_USER=myapp_user
DB_PASSWORD=StrongPass@2025
DATABASE_URL=postgresql://myapp_user:StrongPass@2025@my-app-db:5432/myapp

⚠️ Use the service name my-app-db as the host — never localhost or the server IP. Services inside the same Dokploy project communicate with each other via their service names over the internal Docker Swarm network.

✅ 5. (Optional) Expose Externally for pgAdmin or TablePlus

Open your PostgreSQL service → General tab
Under External Credentials, enter an External Port (e.g. 5433)
Click Save
Open that port in the firewall:

   sudo ufw allow 5433/tcp

Connect from your local machine:

   Host: YOUR_SERVER_IP | Port: 5433
   Database: myapp      | User: myapp_user
   Password: StrongPass@2025

9️⃣ Ninth Step — Set Up Redis for Your App

Dokploy runs its own internal Redis for managing its deployment queue. The one you create here is completely separate — it is your application's cache/session/queue store.

✅ 1. Add a Redis Service

Inside your project → Create New Service → Database → Redis
Fill in:

Field	Example Value
Service Name	`my-app-cache`
Redis Password	`RedisPass@2025`
Redis Version	`7`

Click Create

✅ 2. Deploy Redis

Go to the General tab → Click Deploy → Wait for Running (green)

✅ 3. Get the Internal Connection Strings

REDIS_HOST=my-app-cache
REDIS_PORT=6379
REDIS_PASSWORD=RedisPass@2025
REDIS_URL=redis://:RedisPass@2025@my-app-cache:6379

Redis supports database numbers 0–15. Use them to separate concerns:

CACHE_URL=redis://:RedisPass@2025@my-app-cache:6379/0
SESSION_URL=redis://:RedisPass@2025@my-app-cache:6379/1
QUEUE_URL=redis://:RedisPass@2025@my-app-cache:6379/2

✅ 4. (Optional) Expose Externally for RedisInsight

Open your Redis service → General tab
Under External Credentials, enter External Port 6379
Click Save
Open the port:

   sudo ufw allow 6379/tcp

In RedisInsight, connect with:
- Host: YOUR_SERVER_IP | Port: 6379
- Username: default | Password: RedisPass@2025

🔟 Tenth Step — Deploy Your Application

✅ 1. Add an Application Service

Inside your project → Create New Service → Application

Choose a source:

GitHub / GitLab — connects your repo with auto CI/CD on every push
Docker Compose — upload your own docker-compose.yml
Docker Image — pull from Docker Hub or any registry

✅ 2. Set Environment Variables

In the Environment tab, add your connection strings:

DATABASE_URL=postgresql://myapp_user:StrongPass@2025@my-app-db:5432/myapp
REDIS_URL=redis://:RedisPass@2025@my-app-cache:6379
PORT=3333
NODE_ENV=production

Click Save.

✅ 3. Configure a Domain

Domains tab → Add Domain
Enter your app's subdomain (e.g. app.yourdomain.com)
Set Container Port to whatever your app listens on (e.g. 3333)
Select Let's Encrypt → Click Save

Make sure app.yourdomain.com has an A record pointing to your server IP.

✅ 4. Deploy and Verify

General tab → Deploy → Watch the live logs → Visit https://app.yourdomain.com

📝 Ubuntu Troubleshooting

⭐ Port 3000 Not Accessible

sudo ufw status
sudo ufw allow 3000/tcp
docker service ls
docker ps | grep dokploy

⭐ SSL Certificate Not Issued

# Check Traefik logs for Let's Encrypt errors
docker logs $(docker ps -q -f name=dokploy_dokploy-traefik) 2>&1 | tail -50

# Confirm ports 80 and 443 are open
sudo ufw status

# Confirm DNS resolves to this server
nslookup yourdomain.com

⭐ App Cannot Reach the Database or Redis

The service name must be used — never localhost:

# WRONG
DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
# CORRECT
DATABASE_URL=postgresql://user:pass@my-app-db:5432/mydb

Verify all services share the same network:

docker network inspect dokploy-network

⭐ Docker Does Not Start After Reboot

sudo systemctl enable docker
sudo systemctl start docker
sudo systemctl status docker

🔵 AlmaLinux Guide

Tested on: AlmaLinux 9.x, AlmaLinux 10.x

⚠️ Two things that differ from Ubuntu and will cause failures if skipped:

1. firewalld must be started manually.
On many VPS providers, firewalld is installed but disabled. Running firewall-cmd commands without starting the service first means the rules are written to disk but never enforced — then when --reload is finally called, it activates firewalld for the first time and resets your SSH connection.
Always enable and start firewalld before running any firewall-cmd rule.

2. Docker must be installed manually before Dokploy.
Dokploy's bundled Docker install script uses Docker's convenience helper which returns Unsupported distribution 'almalinux' and the Dokploy installation fails entirely. Install Docker from Docker's official CentOS/RHEL repository first. Step 3 covers this exactly.

1️⃣ First Step — Connect to Your VPS

✅ 1. Get Your Credentials from Your Hosting Provider

IP address: YOUR_SERVER_IP
Username: root
Password: YOUR_PASSWORD

✅ 2. Connect via Terminal

ssh root@YOUR_SERVER_IP

✅ 3. Accept the Host Key

Are you sure you want to continue connecting (yes/no/[fingerprint])?

Type yes and press Enter.

✅ 4. Enter Your Password When Prompted

root@YOUR_SERVER_IP's password:

Paste your password and press Enter. No characters appear while typing — that is normal.

✅ 5. You're In

[root@your-hostname ~]#

2️⃣ Second Step — Prepare the System

✅ 1. Clear the Terminal

clear

✅ 2. Confirm Your OS

cat /etc/os-release

Expected:

NAME="AlmaLinux"
VERSION="9.x (Seafoam Ocelot)"
ID="almalinux"
ID_LIKE="rhel centos fedora"

✅ 3. Enable the EPEL Repository
EPEL (Extra Packages for Enterprise Linux) is required for several packages on AlmaLinux:

sudo dnf install -y epel-release

✅ 4. Check for Available Updates

sudo dnf check-update

Exit code 100 is normal — it means updates are available.

✅ 5. Apply All Updates

sudo dnf upgrade -y

✅ 6. Install Essential Tools

sudo dnf install -y curl wget ca-certificates dnf-plugins-core

✅ 7. Reboot If a Kernel Update Was Applied

sudo reboot

Reconnect via SSH after the server comes back up.

3️⃣ Third Step — Install Docker (Mandatory Before Dokploy on AlmaLinux)

⚠️ Do not skip this step and do not run the Dokploy installer before completing it.

Dokploy's built-in Docker setup uses Docker's convenience install script. On AlmaLinux that script exits with:
ERROR: Unsupported distribution 'almalinux'
The fix is to install Docker yourself from Docker's official CentOS repository, which AlmaLinux is fully binary-compatible with. Once Docker is present on the system, the Dokploy installer detects it and skips its own Docker step.

✅ 1. Remove Any Old or Conflicting Docker Packages

sudo dnf remove -y docker docker-client docker-client-latest docker-common \
  docker-latest docker-latest-logrotate docker-logrotate docker-engine

If none are installed this command just exits cleanly.

✅ 2. Add Docker's Official Repository
AlmaLinux uses the same repository as CentOS/RHEL:

sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

✅ 3. Install Docker Engine and Compose Plugin

sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

When prompted to accept a GPG key, type y and press Enter.

✅ 4. Enable Docker to Start on Boot and Start It Now
On AlmaLinux, services do not auto-start after installation. You must enable them explicitly:

sudo systemctl enable --now docker

✅ 5. Verify the Installation

docker --version
docker compose version

Expected (verified on real AlmaLinux 10.1 server, March 2026):

Docker version 29.3.0, build ...
Docker Compose version v5.1.0

✅ 6. Run a Quick Test

docker run hello-world

You should see Hello from Docker!. Docker is ready. The Dokploy installer will now succeed.

4️⃣ Fourth Step — Configure the Firewall

⚠️ AlmaLinux uses firewalld, not ufw. All firewall commands use firewall-cmd.

The most important rule: start and enable firewalld before running any firewall-cmd commands. If firewalld is not running when you call --reload, that command starts the service for the first time, enforces the new rules, and your SSH session drops because the --permanent rules you added were incomplete at that point.

The order is: start firewalld → confirm SSH is allowed → add ports → reload.

✅ 1. Enable and Start firewalld

sudo systemctl enable firewalld
sudo systemctl start firewalld

✅ 2. Confirm firewalld Is Active

sudo systemctl status firewalld

Look for Active: active (running):

● firewalld.service - firewalld - dynamic firewall daemon
     Loaded: loaded (/usr/lib/systemd/system/firewalld.service; enabled; ...)
     Active: active (running) since ...

✅ 3. Check What the Default Zone Already Allows

sudo firewall-cmd --list-all

The public zone includes ssh by default. You will see a line like:

services: cockpit dhcpv6-client ssh

⚠️ This is the output of the command — it shows which services are currently allowed. Do not run cockpit dhcpv6-client ssh as a command. It is not a command, it is information.

✅ 4. Explicitly Persist SSH as a Permanent Rule (Safety Step)
Even though SSH is in the default zone, make it permanent so it survives any zone resets:

sudo firewall-cmd --permanent --add-service=ssh

✅ 5. Open the Remaining Required Ports

sudo firewall-cmd --permanent --add-port=80/tcp
sudo firewall-cmd --permanent --add-port=443/tcp
sudo firewall-cmd --permanent --add-port=3000/tcp

✅ 6. Reload firewalld to Enforce All Rules

sudo firewall-cmd --reload

Your SSH session will stay connected because SSH was explicitly made permanent in step 4 before this reload.

✅ 7. Verify Open Ports and Services

sudo firewall-cmd --list-ports
sudo firewall-cmd --list-services

Expected ports:

80/tcp 443/tcp 3000/tcp

Expected services (SSH must be listed):

cockpit dhcpv6-client ssh

✅ 8. Allow SELinux Network Connections (AlmaLinux Specific)
AlmaLinux runs SELinux in enforcing mode by default. Without this, containers cannot make outbound network connections:

sudo setsebool -P httpd_can_network_connect 1

Confirm it is set:

getsebool httpd_can_network_connect

Expected:

httpd_can_network_connect --> on

5️⃣ Fifth Step — Install Dokploy

✅ 1. Set the Advertise Address
The Dokploy installer cannot always auto-detect the IP on AlmaLinux. Set it manually before running the installer:

export ADVERTISE_ADDR="YOUR_SERVER_IP"

Replace with your actual VPS IP.

✅ 2. (Optional) Pin the Dokploy Version
To install a specific verified version (recommended for stability):

export DOKPLOY_VERSION="v0.28.6"

Skip this to get the latest stable version automatically.

✅ 3. Run the Official Dokploy Installer

curl -sSL https://dokploy.com/install.sh | sh

Because Docker is already installed, the installer skips its own Docker step and goes straight to deploying the Dokploy platform services:

dokploy — the web panel
dokploy-postgres — PostgreSQL 16 (Dokploy's own internal database)
dokploy-redis — Redis 7 (Dokploy's own deployment queue)
dokploy-traefik — reverse proxy for routing and SSL

✅ 4. Wait for All Services to Start
The installer will print:

Congratulations, Dokploy is installed!
Wait 15 seconds for the server to start
Please go to http://YOUR_SERVER_IP:3000

Wait the full 15 seconds before opening the browser.

✅ 5. Confirm All Services Are Running

docker service ls

Every service must show 1/1 under REPLICAS:

NAME               MODE         REPLICAS   IMAGE
dokploy            replicated   1/1        dokploy/dokploy:latest
dokploy-postgres   replicated   1/1        postgres:16
dokploy-redis      replicated   1/1        redis:7
dokploy-traefik    replicated   1/1        traefik:v3.6.7

✅ 6. Confirm the Panel Responds

curl -I http://127.0.0.1:3000/

Expected:

HTTP/1.1 302 Found
Location: /register

6️⃣ Sixth Step — Create Your Admin Account

✅ 1. Open the Panel in Your Browser

http://YOUR_SERVER_IP:3000

You will be redirected to the registration page.

✅ 3. Explore the Dashboard

Projects — create and manage apps and databases
Settings → Server — configure your domain and SSL
Settings → Destinations — configure S3 backup storage

7️⃣ Seventh Step — Point a Domain to Dokploy

✅ 1. Add DNS Records at Your Domain Provider

Type	Name	Value	TTL
`A`	`@`	`YOUR_SERVER_IP`	1 hour
`A`	`www`	`YOUR_SERVER_IP`	1 hour

For a subdomain panel (e.g. panel.xyz.com) add A with name panel.

✅ 2. Verify DNS Propagation

nslookup yourdomain.com

Expected:

Name:    yourdomain.com
Address: YOUR_SERVER_IP

DNS can take up to 48 hours globally, but usually resolves in 5–30 minutes.

✅ 3. Set the Domain Inside Dokploy

Go to Settings → Server
Enter your domain under Dokploy Panel Domain
Select Let's Encrypt
Enter your email address for SSL notifications
Click Save

Dokploy's Traefik will automatically request and renew the certificate.

✅ 4. Verify HTTPS Is Working

https://yourdomain.com

You should see the Dokploy login page with a padlock in the browser address bar.

✅ 5. (Optional) Remove Direct IP Access

After confirming HTTPS works on your domain:

docker service update --publish-rm "published=3000,target=3000,mode=host" dokploy

⚠️ Only run this after your domain and HTTPS are fully confirmed.

8️⃣ Eighth Step — Set Up PostgreSQL for Your App

Dokploy runs its own internal PostgreSQL for its own data. The one you create here is completely separate — it is your application's database.

✅ 1. Create a Project

Click Projects → New Project
Enter a name (e.g. my-app) → Click Create

✅ 2. Add a PostgreSQL Database

Inside the project → Create New Service → Database → PostgreSQL
Fill in the fields:

Field	Example Value
Service Name	`my-app-db`
Database Name	`myapp`
Database User	`myapp_user`
Database Password	`StrongPass@2025`
PostgreSQL Version	`16`

Click Create

✅ 3. Deploy the Database

Go to the General tab → Click Deploy → Wait for the status to turn green (Running)

✅ 4. Get the Internal Connection Strings

The Internal Host shown in the Dokploy UI is the service name. Use it as the hostname in your app's environment variables:

DB_HOST=my-app-db
DB_PORT=5432
DB_NAME=myapp
DB_USER=myapp_user
DB_PASSWORD=StrongPass@2025
DATABASE_URL=postgresql://myapp_user:StrongPass@2025@my-app-db:5432/myapp

⚠️ Use the service name my-app-db as the host — never localhost or the server IP. Services inside the same Dokploy project communicate via service names over the internal Docker Swarm network.

✅ 5. (Optional) Expose Externally for pgAdmin or TablePlus

Open your PostgreSQL service → General tab
Under External Credentials, enter an External Port (e.g. 5433)
Click Save
Open that port in the firewall:

   sudo firewall-cmd --permanent --add-port=5433/tcp
   sudo firewall-cmd --reload

Connect from your local machine:

   Host: YOUR_SERVER_IP | Port: 5433
   Database: myapp      | User: myapp_user
   Password: StrongPass@2025

9️⃣ Ninth Step — Set Up Redis for Your App

Dokploy runs its own internal Redis for its deployment queue. The one you create here is completely separate — it is your application's cache/session/queue store.

✅ 1. Add a Redis Service

Inside your project → Create New Service → Database → Redis
Fill in:

Field	Example Value
Service Name	`my-app-cache`
Redis Password	`RedisPass@2025`
Redis Version	`7`

Click Create

✅ 2. Deploy Redis

Go to the General tab → Click Deploy → Wait for Running (green)

✅ 3. Get the Internal Connection Strings

REDIS_HOST=my-app-cache
REDIS_PORT=6379
REDIS_PASSWORD=RedisPass@2025
REDIS_URL=redis://:RedisPass@2025@my-app-cache:6379

Redis supports database numbers 0–15 for separating use cases:

CACHE_URL=redis://:RedisPass@2025@my-app-cache:6379/0
SESSION_URL=redis://:RedisPass@2025@my-app-cache:6379/1
QUEUE_URL=redis://:RedisPass@2025@my-app-cache:6379/2

✅ 4. (Optional) Expose Externally for RedisInsight

Open your Redis service → General tab
Under External Credentials, enter External Port 6379
Click Save
Open the port:

   sudo firewall-cmd --permanent --add-port=6379/tcp
   sudo firewall-cmd --reload

In RedisInsight, connect with:
- Host: YOUR_SERVER_IP | Port: 6379
- Username: default | Password: RedisPass@2025

🔟 Tenth Step — Deploy Your Application

✅ 1. Add an Application Service

Inside your project → Create New Service → Application

Choose a source:

GitHub / GitLab — connects your repo with auto CI/CD on every push
Docker Compose — upload your own docker-compose.yml
Docker Image — pull from Docker Hub or any registry

✅ 2. Set Environment Variables

In the Environment tab:

DATABASE_URL=postgresql://myapp_user:StrongPass@2025@my-app-db:5432/myapp
REDIS_URL=redis://:RedisPass@2025@my-app-cache:6379
PORT=3333
NODE_ENV=production

Click Save.

✅ 3. Configure a Domain

Domains tab → Add Domain
Enter your app's subdomain (e.g. app.yourdomain.com)
Set Container Port to whatever your app listens on (e.g. 3333)
Select Let's Encrypt → Click Save

Make sure app.yourdomain.com has an A record pointing to your server IP.

✅ 4. Deploy and Verify

General tab → Deploy → Watch the live logs → Visit https://app.yourdomain.com

📝 AlmaLinux Troubleshooting

⭐ SSH Disconnected After `firewall-cmd --reload`

This means firewalld was not running before you ran the reload, so the command activated the service for the first time and reset the connection. To recover without SSH:

Log in via your VPS provider's web console / VNC (not SSH)
Run:

   sudo systemctl start firewalld
   sudo firewall-cmd --permanent --add-service=ssh
   sudo firewall-cmd --reload

SSH will now work normally again

⭐ `cockpit: command not found` Error

This is harmless. It happens when the output of firewall-cmd --list-services (cockpit dhcpv6-client ssh) is accidentally run as a bash command. The output is just showing which services are allowed — it is not something you run. Ignore it.

⭐ Dokploy Installer Fails with "Unsupported distribution"

Docker was not installed before the Dokploy installer ran. Go back to Step 3:

sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker

export ADVERTISE_ADDR="YOUR_SERVER_IP"
curl -sSL https://dokploy.com/install.sh | sh

⭐ Swarm Init Fails / Cannot Detect IP

Always export ADVERTISE_ADDR before running the installer:

export ADVERTISE_ADDR="YOUR_SERVER_IP"
curl -sSL https://dokploy.com/install.sh | sh

⭐ Port 3000 Not Accessible

sudo firewall-cmd --list-ports
sudo firewall-cmd --permanent --add-port=3000/tcp
sudo firewall-cmd --reload
docker service ls
docker ps | grep dokploy

⭐ SSL Certificate Not Issued

# Check Traefik logs for Let's Encrypt errors
docker logs $(docker ps -q -f name=dokploy_dokploy-traefik) 2>&1 | tail -50

# Confirm ports 80 and 443 are open
sudo firewall-cmd --list-ports
sudo firewall-cmd --list-services

# Confirm DNS resolves to this server
nslookup yourdomain.com

⭐ App Cannot Reach the Database or Redis

The service name must be used — never localhost:

# WRONG
DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
# CORRECT
DATABASE_URL=postgresql://user:pass@my-app-db:5432/mydb

Verify all services share the same network:

docker network inspect dokploy-network

⭐ SELinux Blocking Container Connections

sudo setsebool -P httpd_can_network_connect 1
# Check what SELinux is denying
sudo ausearch -m avc -ts recent

⭐ Services Do Not Start After Reboot

Both firewalld and docker must be enabled to survive reboots:

sudo systemctl enable firewalld
sudo systemctl enable docker
sudo systemctl status firewalld
sudo systemctl status docker

⭐ Containers Crash with `bridge-nf-call-iptables: permission denied` (OpenVZ / Shared-Kernel VPS)

Symptom: All Dokploy services crash in a restart loop immediately after installation. Running docker service ps dokploy-postgres --no-trunc shows repeated failures with this error:

"starting container failed: failed to set up container networking: error creating
external connectivity network: open /proc/sys/net/bridge/bridge-nf-call-iptables:
permission denied"

Root cause: Your VPS is running on OpenVZ (or a similar container-based virtualization platform) with a shared kernel. The host provider has restricted access to bridge networking kernel features. No command you run inside your VPS can fully fix this — the kernel is shared with other customers and the provider controls these capabilities at the host level.

You can identify an OpenVZ VPS by running:

systemd-detect-virt
# or
hostnamectl | grep Virtualization

If the output is openvz or lxc, you are on a shared kernel.

Option 1 — Disable Docker's iptables (Try First)

This tells Docker not to use iptables for container networking, which avoids the permission error entirely:

# 1. Stop everything and leave the swarm
docker swarm leave --force

# 2. Remove any leftover Dokploy containers and volumes
docker container prune -f
docker volume prune -f
docker network prune -f

# 3. Configure Docker daemon to skip iptables
cat > /etc/docker/daemon.json << 'EOF'
{
  "iptables": false,
  "ip-masq": false
}
EOF

# 4. Restart Docker
sudo systemctl restart docker
sudo systemctl status docker

# 5. Reinstall Dokploy
export DOCKER_IGNORE_BR_NETFILTER_ERROR=1
export ADVERTISE_ADDR="YOUR_SERVER_IP"
export DOKPLOY_VERSION="v0.28.6"
curl -sSL https://dokploy.com/install.sh | sh

⚠️ Trade-off: Disabling iptables means Docker will not set up NAT rules for containers automatically. Traffic routing between your app containers and the outside world depends entirely on Traefik (which Dokploy includes). For most Dokploy use cases this is fine, but direct port-forwarding from host to container will not work without manual iptables rules.

Option 2 — Contact Your Hosting Provider (Most Reliable)

If Option 1 fails, the only permanent fix is at the host level. Open a support ticket with your provider and include the following:

"I need the following kernel features enabled for my VPS:

bridge and br_netfilter kernel modules loaded

net.bridge.bridge-nf-call-iptables=1 set on the host node

net.bridge.bridge-nf-call-ip6tables=1 set on the host node

TUN/TAP device access enabled

I am running Docker Swarm, which requires these. I am currently getting:
open /proc/sys/net/bridge/bridge-nf-call-iptables: permission denied"

💡 Long-term recommendation: If your provider cannot enable these features, consider migrating to a KVM-based VPS (sometimes called "full virtualization" or "dedicated kernel" VPS). KVM gives your VPS its own isolated kernel where you have full control over kernel modules and sysctl settings. OpenVZ/LXC VPS plans are cheaper but impose these kernel-sharing restrictions that are incompatible with Docker Swarm.

⚙️ Managing Dokploy (Both OS)

# List all Dokploy platform services and their status
docker service ls

# List all running containers
docker ps

# View Dokploy panel logs
docker logs $(docker ps -q -f name=dokploy_dokploy)

# View Traefik logs (SSL and routing issues)
docker logs $(docker ps -q -f name=dokploy_dokploy-traefik)

# Force restart the Dokploy panel
docker service update --force dokploy_dokploy

# Check system resource usage live
docker stats

# Check disk usage
df -h

# Check memory
free -h

Update Dokploy to the Latest Version

curl -sSL https://dokploy.com/install.sh | sh -s update

🔑 Ubuntu vs AlmaLinux — Key Differences

Area	Ubuntu	AlmaLinux
Package manager	`apt`	`dnf`
Docker install	Auto by Dokploy installer	Must install manually first (Step 3)
Docker repository	`download.docker.com/linux/ubuntu`	`download.docker.com/linux/centos`
Firewall tool	`ufw`	`firewall-cmd` (firewalld)
Start firewall	`ufw enable` (starts itself)	`systemctl enable firewalld && systemctl start firewalld` first — then add rules
SSH safety step	`ufw allow 22/tcp` before `ufw enable`	`firewall-cmd --permanent --add-service=ssh` before `--reload`
Firewall persistence	`ufw enable` persists rules	`--permanent` flag persists rules
SELinux	Inactive by default	Active — must run `setsebool -P httpd_can_network_connect 1`
Service auto-start	Services start automatically after install	Must run `systemctl enable` manually
EPEL repo	Not needed	Required — `dnf install epel-release` in Step 2
Advertise address	Usually auto-detected	Must set `export ADVERTISE_ADDR` manually before installer
Virtualization risk	Rare	Check for OpenVZ — see bridge-nf-call-iptables troubleshooting

📚 Official References

I Threw Away My ILIKE Queries and My Search Bar Finally Works - MeiliSearch

Subham — Fri, 01 May 2026 21:57:55 +0000

🔥Connect: https://xam-heisenberg-company.vercel.app/
🔥GitHub: https://github.com/Subham-Maity
🔥Twitter: https://twitter.com/TheSubhamMaity
🔥LinkedIn: https://www.linkedin.com/in/subham-xam
🔥Insta: https://www.instagram.com/subham_xam

MeiliSearch - The Complete Production Setup Guide (2026)

How I Ended Up Down the Search Engine Rabbit Hole

Okay so here's the thing. I was building a personal finance tracker for myself. Nothing fancy, just something to manage my accounts, transactions, EMI schedules, investment positions... you know, the usual "I got tired of 10 Google Sheets" kind of project. The backend was NestJS + Postgres/Prisma, clean architecture, the works.

At some point I added a global search bar to the frontend. Cmd+K style. You type, results appear across accounts, investments, transactions, all at once. Simple enough to want. Absolutely not simple to build correctly.

My first thought was "just ILIKE %query% in Postgres." Worked for 2 minutes. Then I tried to search for something with a typo and got zero results. Tried to search across 3 tables at once and ended up with the most cursed SQL JOIN you've ever seen. Tried to highlight matching text and gave up.

That's when I actually sat down and looked at what people use for this properly.

Picking a Search Engine: The Honest Comparison

Here's the deal — there are more options than you'd expect, and most tutorials just pick one without explaining why. Let me actually show you the landscape:

Engine	Open Source	Typo Tolerance	Hosting	Setup Complexity	Speed	Best For
Elasticsearch	Yes (BSL)	Configurable	Self-host / Elastic Cloud	High — JVM, configs, mappings	Fast at scale	Log analytics, massive datasets, enterprise
OpenSearch	Yes (Apache 2)	Configurable	Self-host / AWS	High — same as ES	Fast at scale	AWS shops, ES alternative
Algolia	No (SaaS)	Built-in	Managed only	Very low	Very fast	Startups with budget, e-commerce
Typesense	Yes (GPL)	Built-in	Self-host / Cloud	Medium	Very fast	Algolia alternative, smaller datasets
MeiliSearch	Yes (MIT)	Built-in	Self-host	Low	Very fast	Developer experience, side projects to production
Postgres FTS	Yes	No	Same DB	Zero	Okay	Simple apps, already on Postgres
SQLite FTS5	Yes	No	Same DB	Zero	Fast for small	CLI tools, local apps

Here's my honest take after going through this:

Elasticsearch is incredibly powerful but it genuinely feels like you need a DevOps certification to operate it in production. It's a JVM app. The config surface area is enormous. For log analytics at scale? Perfect. For a product search bar on a side project? Way overkill.

Algolia is the opposite — it just works, the DX is amazing, and you'll have search running in 20 minutes. Then you look at the pricing for anything above 10k operations/month and close the tab.

Typesense is solid and worth looking at. The API is clean, performance is great. Honestly, if you're choosing between Typesense and MeiliSearch today, it's genuinely close.

MeiliSearch is what I went with. MIT licensed, Docker image is tiny (~50MB), search results appear in <50ms in most cases, typo tolerance works out of the box, and the JS SDK is properly typed. The configuration model is simple enough that I understood the whole thing in one afternoon. It also has the best NestJS integration story of the bunch.

If you're on Postgres already and your search needs are genuinely simple (one table, no typo tolerance needed), pg_trgm or full text search is worth trying first. But the moment you want multi-index search, typo tolerance, or highlighted snippets — reach for a dedicated engine.

I'm using MeiliSearch. The rest of this post is the complete production setup.

Before You Touch Any Code — Read These Five Rules

I spent about half a day debugging issues that all traced back to violating one of these. Saving you the pain:

Rule 1 — MEILISEARCH_URL is the only thing that changes between environments.
Your NestJS code never hardcodes a host. It always reads from process.env.MEILISEARCH_URL. The .env file is what changes per machine, per deployment topology. Code stays identical everywhere.

Rule 2 — Never use the Master Key in your application code.
The master key is a one-time bootstrap tool. Use it once to generate scoped API keys, then your app only ever uses those scoped keys. The master key never appears in search.service.ts or any NestJS code.

Rule 3 — Always pin the MeiliSearch Docker image version.
Never use :latest. It silently upgrades between incompatible versions and corrupts your database on restart. Always pin: getmeili/meilisearch:v1.37.0.

Rule 4 — MEILI_ENV=production is not optional.
Development mode accepts unauthenticated requests — a security hole. Production mode enforces API key auth on every request. Always set this regardless of environment.

Rule 5 — Port 7700 must always be reachable from wherever NestJS runs.
MeiliSearch always runs in Docker. NestJS might run in Docker, raw on the same machine, or on a completely different server. The only requirement: port 7700 on the MeiliSearch host must be reachable from wherever NestJS is.

How `MEILISEARCH_URL` Works Across All Deployments

This is the entire mental model. Everything else follows from it.

Deployment scenario	Where NestJS runs	Where MeiliSearch runs	`MEILISEARCH_URL` in `.env`
Local dev — both in Docker Compose	Docker container	Docker container (same compose)	`http://meilisearch:7700`
Local dev — NestJS raw, Meili in Docker	Directly on Windows/Mac/Linux host	Docker on same machine	`http://localhost:7700`
Production — both in Docker Compose	Docker container	Docker container (same compose)	`http://meilisearch:7700`
Production — NestJS on server, Meili on same server	Directly on Linux server	Same server (Docker, port exposed)	`http://localhost:7700`
Production — NestJS on one server, Meili on separate server	Server A	Server B	`http://<SERVER_B_IP>:7700`

The rule in one sentence: If NestJS and MeiliSearch are in the same Docker Compose network, use the service name meilisearch. If NestJS is outside Docker (running raw on a host), use localhost or the remote server IP depending on where MeiliSearch is.

Most of us doing local dev run NestJS raw (npm run start:dev) and MeiliSearch in Docker. That's Scenario A:

Your Machine
├── NestJS → runs raw (npm run start:dev)
└── Docker Desktop
    └── meilisearch container → port 7700 exposed to host

Your .env just needs:

MEILISEARCH_URL=http://localhost:7700

When Docker exposes ports: "7700:7700", port 7700 inside the container maps to port 7700 on your machine. Your NestJS talks to localhost:7700 like any other local service. Works on Windows, Mac, Linux as long as Docker Desktop is running.

Directory Structure

Here's what the full setup looks like before we start writing files:

project-root/
├── .env                              ← secrets for this machine — never commit
├── .env.example                      ← committed template with placeholder values
├── docker-compose.yml                ← runs MeiliSearch (and optionally your app)
├── Dockerfile                        ← only needed if you run NestJS in Docker too
├── scripts/
│   └── create-meili-keys.sh          ← one-time key generation (run once per environment)
└── src/
    └── search/
        ├── index.ts                  ← barrel
        ├── search.module.ts          ← @Global module
        ├── search.service.ts         ← MeiliSearch client wrapper
        ├── search.config.ts          ← config via ConfigService
        └── indexes/
            ├── index.ts              ← barrel
            └── [feature].index.ts   ← one file per index (settings + type-safe queries)

⚠️ Important SDK Fixes — Read Before Writing Any Code (v0.40+)

Three breaking changes caught me off guard. Flagging them upfront:

1. Client casing changed. The meilisearch npm package updated its primary export from MeiliSearch to Meilisearch (lowercase s). If you hit TypeError: MeiliSearch is not a constructor, this is why. Use the lowercase variant everywhere:

// ❌ Old
import { MeiliSearch } from 'meilisearch';
const client = new MeiliSearch({ ... });

// ✅ Current
import { Meilisearch } from 'meilisearch';
const client = new Meilisearch({ ... });

2. waitForTask moved. client.waitForTask() no longer exists on the root client. Use client.tasks.waitForTask(uid). Also, tasks that fail (like "index already exists") no longer throw — they return a task object where status === 'failed'. Always check completedTask.status === 'failed' explicitly.

3. Rate limiting on search endpoints. A global search bar triggering parallel requests (hitting /search for 4 indices at once) will instantly exhaust default NestJS Throttler limits (10 req/min), giving HTTP 429. Fix: add @Throttle({ default: { limit: 120, ttl: 60000 } }) on your search controllers.

Step 1 — `.env` File

Create .env in your project root. Never commit this file.

# ─── MeiliSearch ─────────────────────────────────────────────────────────────
#
# Set MEILISEARCH_URL to match YOUR deployment topology:
#
#   NestJS in Docker + MeiliSearch in same Docker Compose:
#     MEILISEARCH_URL=http://meilisearch:7700
#
#   NestJS running raw on same machine as MeiliSearch Docker:
#     MEILISEARCH_URL=http://localhost:7700
#
#   NestJS on a separate server from MeiliSearch:
#     MEILISEARCH_URL=http://<MEILISEARCH_SERVER_IP>:7700
#
MEILISEARCH_URL=http://localhost:7700

MEILISEARCH_MASTER_KEY=your-master-key-minimum-16-chars-change-this
MEILISEARCH_BACKEND_KEY=fill-this-in-after-step-4
MEILISEARCH_SEARCH_KEY=fill-this-in-after-step-4

Commit .env.example (safe to commit, no real values):

MEILISEARCH_URL=REPLACE_ME_see_comments_above
MEILISEARCH_MASTER_KEY=REPLACE_ME_min_16_chars
MEILISEARCH_BACKEND_KEY=REPLACE_ME_after_key_generation
MEILISEARCH_SEARCH_KEY=REPLACE_ME_after_key_generation

Generate a strong master key: openssl rand -hex 32
Minimum 16 characters required in production mode. 32+ recommended.

Step 2 — `docker-compose.yml`

This file runs MeiliSearch. It does not include your NestJS app — your app runs however you normally run it (npm run start:dev, node dist/main.js, or in its own Docker container). MeiliSearch is always the only required service here.

services:
  meilisearch:
    image: getmeili/meilisearch:v1.37.0   # ← pinned version, never :latest
    restart: unless-stopped               # auto-restarts on server reboot or crash
    ports:
      - "7700:7700"                       # exposes port to host
    environment:
      - MEILI_ENV=production              # enforces API key auth on ALL requests
      - MEILI_MASTER_KEY=${MEILISEARCH_MASTER_KEY}
      - MEILI_DB_PATH=/meili_data/data.ms
      - MEILI_DUMP_DIR=/meili_data/dumps
      - MEILI_SNAPSHOT_DIR=/meili_data/snapshots
      - MEILI_SNAPSHOT_INTERVAL_SEC=86400  # auto-snapshot every 24h
    volumes:
      - meilidata:/meili_data              # named volume — works on Windows, Mac, Linux
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7700/health"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 20s

volumes:
  meilidata:

Why each decision:

ports: 7700:7700 — always exposed regardless of topology. NestJS outside Docker reaches via localhost:7700. NestJS on a remote server reaches via <ip>:7700. NestJS inside the same Docker Compose uses the service name meilisearch:7700 internally — but keeping the port exposed is harmless and allows curl/browser access for debugging.
Named volume meilidata — not a host path. Works cross-platform with no permission issues on Windows or Mac.
restart: unless-stopped — MeiliSearch comes back automatically after machine reboot or Docker Desktop restart.
MEILI_SNAPSHOT_INTERVAL_SEC=86400 — automatic daily snapshots inside the volume. Data is always recoverable without manual steps.
start_period: 20s — health check grace period so Docker doesn't mark it unhealthy while still booting.

If you also want to run NestJS in Docker (e.g. production server), add this optional app service block to the same file:

# ── Optional: add this service only if NestJS runs in Docker too ─────────────
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    env_file:
      - .env
    depends_on:
      meilisearch:
        condition: service_healthy     # waits for MeiliSearch to pass health check
    networks:
      - app-network
    restart: unless-stopped

# ── Add this network block only if you added the app service above ────────────
networks:
  app-network:
    driver: bridge

# ── Also add meilisearch to the same network if you added the app service ─────
# Under the meilisearch service, add:
#   networks:
#     - app-network
# And change MEILISEARCH_URL in .env to: http://meilisearch:7700

Step 3 — `Dockerfile` (Only if NestJS Runs in Docker)

Skip this step entirely if you run NestJS raw with npm run start:dev or node dist/main.js.

FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# ── Production image — no dev dependencies ───────────────────────────────────
FROM node:20-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY --from=builder /app/dist ./dist

EXPOSE 3000
CMD ["node", "dist/main.js"]

Step 4 — Generate Scoped API Keys (One-time Per Environment)

Run this once when you first set up MeiliSearch on any machine. The keys persist in the Docker volume — they survive restarts and reboots.

4a — Start MeiliSearch

docker compose up meilisearch -d

# Wait until healthy
docker compose ps
# meilisearch should show: healthy

Verify it's up from your host machine:

curl http://localhost:7700/health
# → {"status":"available"}

4b — Run the Key Generation Script

On Mac/Linux or Windows WSL/Git Bash:

Create scripts/create-meili-keys.sh:

#!/bin/bash
set -e

if [ -z "$MEILISEARCH_MASTER_KEY" ]; then
  echo "ERROR: MEILISEARCH_MASTER_KEY is not set."
  echo "Run: export MEILISEARCH_MASTER_KEY=your-key"
  exit 1
fi

MEILI_HOST="http://localhost:7700"

echo ""
echo "=== Creating backend key (full write access — NestJS server only) ==="
curl -s -X POST "${MEILI_HOST}/keys" \
  -H "Authorization: Bearer ${MEILISEARCH_MASTER_KEY}" \
  -H "Content-Type: application/json" \
  --data '{
    "name": "backend-key",
    "description": "NestJS backend — write, index, search. Never expose to frontend.",
    "actions": [
      "documents.add",
      "documents.delete",
      "documents.get",
      "indexes.create",
      "indexes.get",
      "indexes.update",
      "indexes.delete",
      "settings.get",
      "settings.update",
      "tasks.get",
      "search"
    ],
    "indexes": ["*"],
    "expiresAt": null
  }'

echo ""
echo "=== Creating search-only key (safe to expose to frontend clients) ==="
curl -s -X POST "${MEILI_HOST}/keys" \
  -H "Authorization: Bearer ${MEILISEARCH_MASTER_KEY}" \
  -H "Content-Type: application/json" \
  --data '{
    "name": "search-key",
    "description": "Frontend search only — read only, no write access.",
    "actions": ["search"],
    "indexes": ["*"],
    "expiresAt": null
  }'

echo ""
echo "=== Done. Copy the 'key' field values above into your .env ==="
echo "  MEILISEARCH_BACKEND_KEY = key from backend-key response"
echo "  MEILISEARCH_SEARCH_KEY  = key from search-key response"

export MEILISEARCH_MASTER_KEY=your-master-key-here
bash scripts/create-meili-keys.sh

On Windows PowerShell (if you don't have WSL/Git Bash):

$masterKey = "your-master-key-here"

# Backend key
curl.exe -X POST "http://localhost:7700/keys" `
  -H "Authorization: Bearer $masterKey" `
  -H "Content-Type: application/json" `
  --data '{\"name\":\"backend-key\",\"actions\":[\"documents.add\",\"documents.delete\",\"documents.get\",\"indexes.create\",\"indexes.get\",\"indexes.update\",\"indexes.delete\",\"settings.get\",\"settings.update\",\"tasks.get\",\"search\"],\"indexes\":[\"*\"],\"expiresAt\":null}'

# Search key
curl.exe -X POST "http://localhost:7700/keys" `
  -H "Authorization: Bearer $masterKey" `
  -H "Content-Type: application/json" `
  --data '{\"name\":\"search-key\",\"actions\":[\"search\"],\"indexes\":[\"*\"],\"expiresAt\":null}'

Copy the key field from each response into your .env:

MEILISEARCH_BACKEND_KEY=paste-backend-key-here
MEILISEARCH_SEARCH_KEY=paste-search-key-here

Key scoping rules (important):

MEILISEARCH_BACKEND_KEY — used by NestJS server code. Full write access. Never sent to browser.
MEILISEARCH_SEARCH_KEY — safe for frontend clients. Search-only, read-only.
MEILISEARCH_MASTER_KEY — used only in this script. Never appears in NestJS code. Never sent anywhere.
Keys are deterministic: same master key → same key values. Safe to regenerate if you lose them.

Step 5 — Install the JS SDK

npm install meilisearch

Official SDK. Fully typed. No community wrapper needed.

Step 6 — NestJS Integration

Four files make up the search infrastructure. All of them live in src/search/.

`src/search/search.config.ts`

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class SearchConfig {
  constructor(private readonly configService: ConfigService) {}

  // Reads MEILISEARCH_URL from .env
  // This is the only place the host is read — never hardcoded anywhere else
  get host(): string {
    const url = this.configService.get<string>('MEILISEARCH_URL');
    if (!url) throw new Error('MEILISEARCH_URL is not set in environment');
    return url;
  }

  // Backend key — used for all server-side operations (write + search)
  get backendApiKey(): string {
    const key = this.configService.get<string>('MEILISEARCH_BACKEND_KEY');
    if (!key) throw new Error('MEILISEARCH_BACKEND_KEY is not set in environment');
    return key;
  }

  // Search key — safe to return to frontend for direct client-side search
  get searchApiKey(): string {
    const key = this.configService.get<string>('MEILISEARCH_SEARCH_KEY');
    if (!key) throw new Error('MEILISEARCH_SEARCH_KEY is not set in environment');
    return key;
  }
}

`src/search/search.service.ts`

This is the wrapper around the MeiliSearch client. All other parts of your app go through this service — they never instantiate their own client.

import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
import { Meilisearch, Index, SearchParams, SearchResponse, Settings } from 'meilisearch';
import { SearchConfig } from './search.config';

@Injectable()
export class SearchService implements OnModuleInit {
  private readonly logger = new Logger(SearchService.name);
  private client: Meilisearch;

  constructor(private readonly config: SearchConfig) {}

  onModuleInit() {
    // host resolves from MEILISEARCH_URL in .env
    // works whether NestJS is in Docker, raw on Windows/Mac/Linux, or on a remote server
    this.client = new Meilisearch({
      host:   this.config.host,
      apiKey: this.config.backendApiKey,
    });

    this.logger.log(`MeiliSearch client initialized → ${this.config.host}`);
  }

  // ─── Health ───────────────────────────────────────────────────────────────

  async ping(): Promise<boolean> {
    try {
      await this.client.health();
      return true;
    } catch {
      return false;
    }
  }

  // ─── Index access ─────────────────────────────────────────────────────────

  getIndex<T>(indexName: string): Index<T> {
    return this.client.index<T>(indexName);
  }

  // ─── Documents ───────────────────────────────────────────────────────────

  async addDocuments<T extends Record<string, unknown>>(
    indexName: string,
    documents: T[],
    primaryKey = 'id',
  ) {
    const task = await this.client.index<T>(indexName).addDocuments(documents, { primaryKey });
    this.logger.log(`Enqueued addDocuments → ${indexName} (task ${task.taskUid})`);
    return task;
  }

  async updateDocuments<T extends Record<string, unknown>>(
    indexName: string,
    documents: T[],
    primaryKey = 'id',
  ) {
    const task = await this.client.index<T>(indexName).updateDocuments(documents, { primaryKey });
    this.logger.log(`Enqueued updateDocuments → ${indexName} (task ${task.taskUid})`);
    return task;
  }

  async deleteDocument(indexName: string, documentId: string | number) {
    const task = await this.client.index(indexName).deleteDocument(documentId);
    this.logger.log(`Enqueued deleteDocument → ${indexName}/${documentId} (task ${task.taskUid})`);
    return task;
  }

  async deleteDocuments(indexName: string, documentIds: Array<string | number>) {
    const task = await this.client.index(indexName).deleteDocuments(documentIds);
    this.logger.log(`Enqueued deleteDocuments → ${indexName} (${documentIds.length} docs, task ${task.taskUid})`);
    return task;
  }

  // ─── Search ───────────────────────────────────────────────────────────────

  async search<T>(
    indexName: string,
    query: string,
    params?: SearchParams,
  ): Promise<SearchResponse<T>> {
    return this.client.index<T>(indexName).search(query, params);
  }

  // ─── Settings ────────────────────────────────────────────────────────────

  async updateIndexSettings(indexName: string, settings: Settings) {
    const task = await this.client.index(indexName).updateSettings(settings);
    this.logger.log(`Enqueued updateSettings → ${indexName} (task ${task.taskUid})`);
    return task;
  }

  // ─── Tasks ───────────────────────────────────────────────────────────────

  async waitForTask(taskUid: number, timeoutMs = 30000) {
    return this.client.waitForTask(taskUid, { timeoutInMs: timeoutMs });
  }

  // ─── Backup ──────────────────────────────────────────────────────────────

  async createDump() {
    const task = await this.client.createDump();
    this.logger.log(`Dump creation enqueued (task ${task.taskUid})`);
    return task;
  }

  // ─── Raw client (escape hatch for SDK features not wrapped above) ─────────

  getClient(): Meilisearch {
    return this.client;
  }
}

`src/search/search.module.ts`

import { Global, Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { SearchConfig } from './search.config';
import { SearchService } from './search.service';

@Global()   // any module can inject SearchService without re-importing SearchModule
@Module({
  imports:   [ConfigModule],
  providers: [SearchConfig, SearchService],
  exports:   [SearchConfig, SearchService],
})
export class SearchModule {}

`src/search/index.ts`

export * from './search.module';
export * from './search.service';
export * from './search.config';
export * from './indexes';

Step 7 — Per-Index Files (One Per Index)

Each index gets its own file. Define searchable/filterable/sortable attributes here. These settings are applied on every app startup via OnModuleInit — idempotent, safe to run repeatedly.

`src/search/indexes/product.index.ts`

This is an example. Replace product with whatever your domain is — investments, accounts, transactions, whatever.

import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
import { SearchService } from '../search.service';

export const PRODUCT_INDEX = 'products';

export interface ProductDocument {
  id:          string;
  name:        string;
  description: string;
  brand:       string;
  category:    string;
  price:       number;
  inStock:     boolean;
  createdAt:   string;
}

@Injectable()
export class ProductIndex implements OnModuleInit {
  private readonly logger = new Logger(ProductIndex.name);

  constructor(private readonly searchService: SearchService) {}

  async onModuleInit() {
    await this.applySettings();
  }

  private async applySettings() {
    try {
      const task = await this.searchService.updateIndexSettings(PRODUCT_INDEX, {
        // Only fields users will search — controls relevance and index size
        searchableAttributes: ['name', 'description', 'brand', 'category'],

        // Fields available for .filter() queries
        filterableAttributes: ['category', 'brand', 'price', 'inStock'],

        // Fields available for .sort() queries
        sortableAttributes: ['price', 'createdAt', 'name'],

        rankingRules: [
          'words',      // more query words matched = higher rank
          'typo',       // fewer typos = higher rank
          'proximity',  // query words closer together = higher rank
          'attribute',  // earlier searchableAttribute = higher rank
          'sort',       // user-specified sort order
          'exactness',  // exact match = higher rank
        ],

        typoTolerance: {
          enabled: true,
          minWordSizeForTypos: {
            oneTypo:  4,   // allow 1 typo for words >= 4 chars
            twoTypos: 8,   // allow 2 typos for words >= 8 chars
          },
        },

        pagination: {
          maxTotalHits: 1000,
        },
      });

      await this.searchService.waitForTask(task.taskUid);
      this.logger.log(`Settings applied → ${PRODUCT_INDEX}`);
    } catch (error) {
      // Log but do not throw — app still starts even if settings fail
      this.logger.error(`Failed to apply settings → ${PRODUCT_INDEX}`, (error as Error).stack);
    }
  }

  // ─── Type-safe query methods ──────────────────────────────────────────────

  async searchProducts(
    query: string,
    options?: {
      category?: string;
      brand?:    string;
      inStock?:  boolean;
      maxPrice?: number;
      page?:     number;
    },
  ) {
    const filters: string[] = [];
    if (options?.category)               filters.push(`category = "${options.category}"`);
    if (options?.brand)                  filters.push(`brand = "${options.brand}"`);
    if (options?.inStock !== undefined)  filters.push(`inStock = ${options.inStock}`);
    if (options?.maxPrice !== undefined) filters.push(`price <= ${options.maxPrice}`);

    return this.searchService.search<ProductDocument>(PRODUCT_INDEX, query, {
      filter:                filters.join(' AND '),
      hitsPerPage:           20,
      page:                  options?.page ?? 1,
      attributesToHighlight: ['name', 'description'],
    });
  }

  async indexProducts(products: ProductDocument[]) {
    return this.searchService.addDocuments(PRODUCT_INDEX, products, 'id');
  }

  async removeProduct(productId: string) {
    return this.searchService.deleteDocument(PRODUCT_INDEX, productId);
  }
}

`src/search/indexes/index.ts`

export * from './product.index';
// export * from './[feature].index';  ← add each new index here

Step 8 — Wire into AppModule

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { SearchModule } from './search';
import { ProductIndex } from './search/indexes';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    SearchModule,
    // ... rest of your modules
  ],
  providers: [
    ProductIndex,   // registers the OnModuleInit settings sync
  ],
})
export class AppModule {}

Step 9 — Start Everything

Scenario A: NestJS raw on same machine, MeiliSearch in Docker

# 1. Start MeiliSearch (Docker Desktop must be running on Windows)
docker compose up meilisearch -d

# 2. Verify it's healthy
curl http://localhost:7700/health
# → {"status":"available"}

# 3. Start NestJS normally
npm run start:dev
# or
npm run start:prod

Your .env has MEILISEARCH_URL=http://localhost:7700.

Scenario B: Both NestJS and MeiliSearch in Docker Compose

docker compose up --build -d
docker compose ps   # both services should show healthy/running

Your .env has MEILISEARCH_URL=http://meilisearch:7700.

Scenario C: NestJS on one server, MeiliSearch on a separate server

# On the MeiliSearch server:
docker compose up meilisearch -d

# On the NestJS server — .env has:
# MEILISEARCH_URL=http://<MEILISEARCH_SERVER_IP>:7700
npm run start:prod

Firewall note for Scenario C: Port 7700 on the MeiliSearch server must allow inbound TCP connections from the NestJS server's IP. Restrict it to only that IP — do not open 7700 to the public internet.

Step 10 — Adding a New Index (Checklist)

Every time you add a new searchable feature, touch these files in order:

1. Create src/search/indexes/my-feature.index.ts

import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
import { SearchService } from '../search.service';

export const MY_FEATURE_INDEX = 'my-feature';

export interface MyFeatureDocument {
  id:    string;
  title: string;
  body:  string;
  // only fields the search actually needs
}

@Injectable()
export class MyFeatureIndex implements OnModuleInit {
  private readonly logger = new Logger(MyFeatureIndex.name);

  constructor(private readonly searchService: SearchService) {}

  async onModuleInit() {
    try {
      const task = await this.searchService.updateIndexSettings(MY_FEATURE_INDEX, {
        searchableAttributes: ['title', 'body'],
        filterableAttributes: ['status', 'authorId'],
        sortableAttributes:   ['createdAt'],
      });
      await this.searchService.waitForTask(task.taskUid);
      this.logger.log(`Settings applied → ${MY_FEATURE_INDEX}`);
    } catch (error) {
      this.logger.error(`Settings failed → ${MY_FEATURE_INDEX}`, (error as Error).stack);
    }
  }

  async search(query: string) {
    return this.searchService.search<MyFeatureDocument>(MY_FEATURE_INDEX, query);
  }

  async index(documents: MyFeatureDocument[]) {
    return this.searchService.addDocuments(MY_FEATURE_INDEX, documents, 'id');
  }
}

2. Add barrel export in src/search/indexes/index.ts:

export * from './my-feature.index';

3. Register in AppModule providers:

providers: [MyFeatureIndex],

4. Export from your feature module if other modules need to inject it:

exports: [MyFeatureIndex],

The Full End-to-End Architecture (Production Pattern)

When you're building something real, you don't want MeiliSearch writes to be synchronous blocking calls in your main request path. If MeiliSearch has a hiccup, you don't want your POST /investments endpoint to fail.

Here's the pattern that handles this correctly:

1. SearchOutboxHelper — Write Events Atomically with Your Entity

Why: If MeiliSearch crashes or is temporarily unavailable, your app must still function. By using the Outbox Pattern, you write the search event into PostgreSQL (your source of truth) within the same transaction as the entity creation. A background worker then safely syncs it to MeiliSearch.

Inside your repository, wrap Prisma queries in a $transaction and call the outbox helper:

import { writeSearchOutbox } from 'src/search/helpers/search-outbox.helper';

async createInvestment(data: any, userId: string) {
  return this.prisma.$transaction(async (tx) => {
    // 1. Create the entity
    const investment = await tx.investments.create({ data });

    // 2. Queue for Search Indexing (Atomic — same transaction)
    await writeSearchOutbox(tx, {
      entity_type: 'investments',
      entity_id: investment.id,
      action: 'UPSERT',
      user_id: userId,
      payload: { ...investment },
    });

    return investment;
  });
}

2. BullMQ Worker — Queue Processing

The SearchQueueService listens for PostgreSQL AuditLog outbox records and enqueues them to BullMQ (search-sync queue). The SearchSyncProcessor consumes these jobs, pushes the payload to MeiliSearch via SearchService, and marks the record as search_synced = true.

If MeiliSearch is down, the jobs stay in the queue and retry. Your core app keeps working.

3. Search Controller — Tenant-Isolated API Route

We don't expose the MeiliSearch search key directly to the frontend — we want backend-level tenant isolation (filter by user_id on every query so users can't see each other's data):

@Get()
@Throttle({ default: { limit: 120, ttl: 60000 } }) // Higher limit for fast debounced typing
async search(
  @GetAdmin('id') userId: string,
  @Query('q') query: string,
  @Query('service') service: string, // e.g. 'investments'
) {
  return this.searchService.search(service, query, { filter: `user_id = "${userId}"` });
}

4. Frontend Integration — Global Search Bar

const handleSearch = useDebouncedCallback(async (query: string) => {
  // Fire requests concurrently across multiple indices
  const [investments, accounts] = await Promise.all([
    axios.get(`/xam/search?q=${query}&service=investments`),
    axios.get(`/xam/search?q=${query}&service=accounts`)
  ]);
  setResults([...investments.data.hits, ...accounts.data.hits]);
}, 300); // 300ms debounce

The @Throttle decorator on the controller is why this works without 429s. Standard NestJS throttler defaults would kill this immediately at 4 concurrent requests per keystroke.

Backup and Recovery

Dumps — Use for Version Migrations

Portable, human-readable export. Works across MeiliSearch versions.

# Create a dump
curl -X POST http://localhost:7700/dumps \
  -H "Authorization: Bearer ${MEILISEARCH_BACKEND_KEY}"
# → returns { "taskUid": 1 }

# Poll until status = "succeeded"
curl http://localhost:7700/tasks/1 \
  -H "Authorization: Bearer ${MEILISEARCH_BACKEND_KEY}"

# Dump file is at /meili_data/dumps/ inside the Docker volume

Snapshots — Use for Fast Rollbacks

Binary-exact copy. Faster to restore than dumps but version-specific — do NOT use across MeiliSearch version upgrades.

Daily auto-snapshots are already configured in the docker-compose.yml above via MEILI_SNAPSHOT_INTERVAL_SEC=86400. Snapshots live at /meili_data/snapshots/ inside the volume.

Upgrading MeiliSearch Versions

# Step 1: Create a dump from the running instance
curl -X POST http://localhost:7700/dumps \
  -H "Authorization: Bearer ${MEILISEARCH_BACKEND_KEY}"

# Step 2: Wait for task to succeed, note the dump filename

# Step 3: Update docker-compose.yml
#   getmeili/meilisearch:v1.37.0  →  getmeili/meilisearch:vX.Y.Z

# Step 4: Temporarily add import command to docker-compose.yml meilisearch service:
#   command: ["meilisearch", "--import-dump=/meili_data/dumps/YOUR_DUMP_FILE.dump"]

# Step 5: Start the new version
docker compose up meilisearch -d

# Step 6: Verify data is intact, then remove the --import-dump command line
# Step 7: Restart normally
docker compose up meilisearch -d --force-recreate

Verify Everything is Connected

# Health check (from host machine — always localhost:7700)
curl http://localhost:7700/health
# → {"status":"available"}

# List API keys (uses master key)
curl http://localhost:7700/keys \
  -H "Authorization: Bearer ${MEILISEARCH_MASTER_KEY}"

# Verify backend key works
curl http://localhost:7700/indexes \
  -H "Authorization: Bearer ${MEILISEARCH_BACKEND_KEY}"

# Check logs
docker compose logs meilisearch
docker compose logs app   # only if NestJS is in Docker

Key API Reference (meilisearch JS SDK)

Quick cheat sheet for the most common operations:

import { Meilisearch } from 'meilisearch';

const client = new Meilisearch({
  host:   process.env.MEILISEARCH_URL,        // from .env — never hardcoded
  apiKey: process.env.MEILISEARCH_BACKEND_KEY,
});

const index = client.index('products');

// Add / update documents
await index.addDocuments(docs, { primaryKey: 'id' });
await index.updateDocuments(docs, { primaryKey: 'id' });

// Delete
await index.deleteDocument('doc-id-123');
await index.deleteDocuments(['id1', 'id2', 'id3']);
await index.deleteAllDocuments();

// Search
const results = await index.search('wireless headphones', {
  filter:                'category = "Electronics" AND price < 200',
  sort:                  ['price:asc'],
  hitsPerPage:           20,
  page:                  1,
  attributesToHighlight: ['name', 'description'],
});
// results.hits            — matched documents
// results.totalHits       — total count
// results.processingTimeMs — query latency in ms

// Settings (idempotent — safe to call on every startup)
await index.updateSettings({
  searchableAttributes: ['name', 'description'],
  filterableAttributes: ['category', 'price'],
  sortableAttributes:   ['price', 'createdAt'],
});

// All write operations are async — poll the task to confirm
const task   = await index.addDocuments(docs);
const result = await client.tasks.waitForTask(task.taskUid); // v0.40+ syntax
// result.status: 'succeeded' | 'failed' | 'enqueued' | 'processing'

// Health
const health = await client.health();
// health.status: 'available'

Common Mistakes Reference

// ❌ Hardcoding the host in application code
const client = new Meilisearch({ host: 'http://localhost:7700' });
// ✅ Always read from environment
const client = new Meilisearch({ host: process.env.MEILISEARCH_URL });

// ❌ Using master key in application code
const client = new Meilisearch({ apiKey: process.env.MEILISEARCH_MASTER_KEY });
// ✅ Use the scoped backend key
const client = new Meilisearch({ apiKey: process.env.MEILISEARCH_BACKEND_KEY });

// ❌ Using :latest Docker image tag
image: getmeili/meilisearch:latest
// ✅ Always pin to a specific version
image: getmeili/meilisearch:v1.37.0

// ❌ MEILI_ENV not set — anyone can hit the API without a key
// ✅ Always set
- MEILI_ENV=production

// ❌ Using MEILISEARCH_URL=http://meilisearch:7700 when NestJS runs outside Docker
//    Docker service names only resolve inside Docker networks
// ✅ Use localhost:7700 when NestJS runs raw on the same machine as Docker

// ❌ Using MEILISEARCH_URL=http://localhost:7700 when NestJS runs inside Docker
//    localhost inside a container = the container itself, not the host
// ✅ Use http://meilisearch:7700 (service name) when both are in same Docker Compose

// ❌ Opening port 7700 to the public internet when MeiliSearch is on a separate server
// ✅ Restrict firewall to allow 7700 only from the NestJS server's IP

// ❌ Host-path volume mounts — permission/performance issues on Windows and Mac
volumes:
  - ./meili_data:/meili_data
// ✅ Named Docker volumes — works everywhere
volumes:
  - meilidata:/meili_data

// ❌ Not setting searchableAttributes — MeiliSearch indexes all fields by default
//    Causes large index sizes and slower search on documents with many fields
// ✅ Always set searchableAttributes explicitly in per-index OnModuleInit

// ❌ Upgrading Docker image version without creating a dump first
// ✅ Always dump → upgrade → import

Wrapping Up

That's the full production setup — Docker config, key management, NestJS service layer, per-index files, the outbox pattern for resilient indexing, backup/recovery, and the common mistakes that'll waste your afternoon.

The thing I actually like about MeiliSearch is that it doesn't fight you. The docker-compose.yml is 30 lines. The JS SDK is properly typed. The search results are genuinely good out of the box. For a Cmd+K style search across multiple entity types in a NestJS app, this is the stack I'd reach for every time now.

If you have questions, drop them in the comments. If you ran into a specific deployment scenario I didn't cover, let me know.

I Built a Free Open Source Tool That Saved Me From Deleting My Production Database (Again)

Subham — Sun, 22 Mar 2026 21:31:21 +0000

🔥Connect: https://xam-heisenberg-company.vercel.app/
🔥GitHub: https://github.com/Subham-Maity
🔥Twitter: https://twitter.com/TheSubhamMaity
🔥LinkedIn: https://www.linkedin.com/in/subham-xam
🔥Insta: https://www.instagram.com/subham_xam

Okay so real talk. I've done it twice.

The first time was during college. I was trying to drop a test table, typed the wrong database name, and wiped out actual user data from a project I was working on with friends. The second time was worse. I was 11pm deep into shipping a feature, ran a migration script, and it quietly nuked 3 months of production records.

Both times I just sat there staring at my screen like 👁️👄👁️

And both times, I had no backup.

So I built ChronoBase a free, open source, local-first database backup manager for PostgreSQL and MongoDB. It runs on your laptop, has a proper web UI, schedules automatic backups, and lets you restore to any database with one click.

No monthly fees. No cloud account. No random company holding your data hostage.

Local-first database backup manager for PostgreSQL & MongoDB. Schedule automatic snapshots, restore to any target, and wipe databases all from a sleek web UI running on your own machine. No cloud, no subscriptions, no BS." width="" height="">

Why does every backup tool either cost money or suck?

Genuinely asked myself this for way too long.

pgAdmin has manual backup buried in menus. MongoDB Compass doesn't really do scheduled backups. Navicat is like $250. Every cloud backup tool wants your credit card just to get started.

For solo devs and indie hackers running multiple side projects, all you really need is:

A place to store all your database connection strings
Something that dumps them automatically on a schedule
The ability to restore any snapshot to any target

That's it. That's the whole thing. Why does this not exist as a simple, free, open source tool?

So I built it.

What ChronoBase actually does

Here's the quick rundown:

Connections — you paste in your PostgreSQL or MongoDB connection URLs, give them a name, group them by project (like Production, Staging, MySaaS). The passwords are masked in the UI so you're not staring at credentials all day.

One-click backup — hit the button, it runs pg_dump or mongodump under the hood, saves the .sql file or MongoDB BSON folder to your local disk. It takes like 2 seconds for small DBs.

Scheduled backups — set a cron expression (0 2 * * * = daily at 2am) and forget about it. The server runs in the background and fires backups while you sleep. You wake up and they're just... there.

Restore — pick any snapshot, choose "same database" (overwrites with the old snapshot) or "push to different DB" (clone to staging, new server, whatever). One click.

Wipe DB — this one's spicy. Sometimes you want to completely nuke the contents of a database before restoring a backup. The Wipe DB button drops every table, every schema (DROP SCHEMA public CASCADE for Postgres), then you restore clean. No leftover junk data.

Danger Zone — full reset with typed confirmation. You literally have to type DELETE EVERYTHING to confirm. Because I've seen what happens when buttons don't have confirmation dialogs.

The tech stack (and why I kept it stupid simple)

Okay so I went with Node.js + Express on the backend and vanilla ES modules on the frontend. No React, no bundler, no build step.

Why? Because I wanted anyone to be able to clone this, read the code, and immediately understand what's happening. No npm run build, no compiled bundle, no mystery.

Data is stored in a plain JSON file (chronobase-data.json). No SQLite, no native modules that break on Node v24 (learned that one the hard way mid-build). If you want to move to a new machine, you literally just copy the folder.

The project structure is modular — one file per concern:

src/
  database.js      ← JSON read/write
  tools.js         ← finds pg_dump/mongodump on your system
  backup.js        ← runs the actual dumps and restores
  scheduler.js     ← manages cron jobs
  routes/          ← one route file per resource

Frontend is the same — public/js/pages/ has one file per page. Clean, readable, zero magic.

The actual hard part: detecting CLI tools across Windows, macOS, and Linux

You know what's annoying? pg_dump lives in completely different places depending on OS, PostgreSQL version, and whether you installed it through an installer, Homebrew, or apt.

The tools.js module checks a list of known paths:

const PG_DUMP_CANDIDATES = [
  'pg_dump',
  '/opt/homebrew/bin/pg_dump',
  'C:\\Program Files\\PostgreSQL\\18\\bin\\pg_dump.exe',
  'C:\\Program Files\\PostgreSQL\\17\\bin\\pg_dump.exe',
  // ... and more
];

It probes each one by running "<path>" --version with a 5 second timeout. First one that responds gets used. Works on every platform without configuration.

The UI shows green/red dots in the sidebar telling you instantly which tools are detected. If something's missing, the Setup page gives you exact install commands for Windows, macOS, and Linux.

How to run it right now (for real, it takes 3 minutes)

git clone https://github.com/Subham-Maity/chronobase.git
cd chronobase
npm install
node server.js

Open http://localhost:3420.

That's it. It's running. Add your first connection string and click Backup.

For Windows you can also double-click START.bat which auto-installs dependencies, starts the server, and opens the browser for you.

Why local-first matters more than you think

Every time you send your database connection string to a cloud backup service, that's another place your credentials live that isn't yours.

ChronoBase keeps everything local. Your .sql files are on your disk. Your connection URLs are in a JSON file on your machine. Nothing is uploaded, transmitted, or stored anywhere external.

For solo devs this is usually fine as-is. For anything with real user data, you obviously want encryption at rest — that's on the roadmap. But the local-first baseline is the right default.

What I want to add next

Current roadmap (also in the README if you want to contribute):

S3 / R2 / Backblaze upload — offsite backup support
Backup compression — gzip .sql files, they can get large
Slack/Discord notifications — ping when a scheduled backup fails
MySQL / MariaDB — same engine, just different CLI tools
Docker image — docker run -p 3420:3420 chronobase
Encryption — AES-256 for stored connection URLs

If any of these sound useful to you, PRs are open. The codebase is intentionally small and readable — a decent Node dev can add a new route in like 20 minutes.

The real reason I'm sharing this

I know there are thousands of devs running side projects and SaaS apps on $5 droplets who don't have a proper backup strategy. It's not because they don't care. It's because setting one up is annoying and all the existing tools are either overkill or paywalled.

This is meant to be the thing that just works. Run it on your laptop or your home server, add your connection strings, set a schedule, and stop thinking about it.

Because the backup you don't have is the one you'll wish you did at 1am when things go wrong.

GitHub: github.com/Subham-Maity/chronobase

If it saves you from a disaster, drop a ⭐ — it genuinely helps the project get discovered.

And if you've had your own database horror story, tell me in the comments. Misery loves company.

Building a Scalable Real-Time Driver Tracking System

Subham — Fri, 16 May 2025 00:05:41 +0000

🔥Connect: https://xam-heisenberg-company.vercel.app/
🔥GitHub: https://github.com/Subham-Maity
🔥Twitter: https://twitter.com/TheSubhamMaity
🔥LinkedIn: https://www.linkedin.com/in/subham-xam
🔥Insta: https://www.instagram.com/subham_xam

Building a Real-Time Delivery Tracking System Using Socket, Redis, Redis streams adapter, Kafka

I recently worked on an exciting project for a client—a delivery app similar to Zomato, where users can track their driver's location live on a map.

The complete application used Flutter for the frontend with both NestJS and Golang powering different versions of the backend.

While I developed two separate implementations, this article focuses purely on the core tracking logic that's completely language-independent.
If you're curious about the actual code, everything is available on GitHub: https://github.com/Subham-Maity/RTLS-Scale.

But don't worry about the specific programming languages—I've designed this guide to be accessible to anyone interested in understanding the fundamental architecture of real-time location tracking systems.

Let me walk you through how I built this prototype, how it works, and how to scale it for real-world applications.

Important disclaimer: this is not production-ready code, as a full commercial implementation would require additional business logic, security considerations, battery optimization, and many other factors I won't cover here. I'm also not addressing driver matching algorithms or distance calculations—this article focuses exclusively on the real-time tracking system architecture.

Along the way, I'll share insights from my experience, including practical advice on backend-frontend communication and what I learned about building reliable real-time systems. By the end, you'll understand exactly how that little moving dot on your food delivery app actually works behind the scenes!

🔥Connect: https://www.subham.online

🔥Repo: https://github.com/Subham-Maity/RTLS-Scale

🔥Twitter: https://twitter.com/TheSubhamMaity

🔥LinkedIn: https://www.linkedin.com/in/subham-xam

How the Prototype Works

Imagine this: you open the prototype in a browser, and there are two buttons—Enter as User or Enter as Driver.
Pretty straightforward, right?

If you pick Driver, the app starts sending your location (latitude and longitude) to the server every few seconds.

If you pick User, you see the driver’s location updating live on a map.

To test it, I opened the driver page on my phone and the user page on my laptop. I walked around a bit with my phone, and on my laptop, I could see my position moving on the map in real-time. It felt satisfying, like “haan, this is working!” But this was just a prototype. In a real app, you’d need proper authentication, middleware, and all that stuff. Here, my focus was on the core logic: how to send the driver’s location to the user continuously, without any hiccups.

Server 1: The Basic WebSocket Setup

Let’s start with the simplest way I did this, using WebSockets. The code for this is in

1. server (socket)/src/websockets/location.gateway.ts

Here’s how it works, step-by-step:

Driver Sends Location: The driver’s app connects to the server using WebSockets and sends a send-location event with their latitude and longitude every few seconds. Think of it like the driver saying, “Hey server, here’s where I am right now!”
Server Broadcasts It: The server listens for this event and sends the location to all connected clients (like the user’s app) using a receive-location event. It’s like the server shouting, “Everyone, here’s the driver’s new position!”
User Updates Map: The user’s app listens for receive-location events and moves the driver’s dot on the map. Simple and quick.

For a small setup, this works like a charm. But then I started thinking—what if there are hundreds or thousands of drivers? Will this still hold up?

Is This Scalable? Not Quite

Here’s where I hit a wall:

Too Many Connections: Every WebSocket connection uses server resources—CPU, memory, etc. With thousands of drivers and users, one server can’t handle it alone. It’ll slow down or crash.
Wasting Data: The server sends every driver’s update to all users. So if there are 100 drivers, each user gets 100 updates every few seconds, even though they only care about their own driver. That’s a lot of useless data clogging the system.
Adding More Servers: If I add more servers to share the load, how do I make sure the right updates reach the right users? Without some clever trick, it’s a headache. Assuming you're a clever programmer, feel free to drop any tricky solutions in the comments 🙂

Verdict: This is fine for a prototype or a small app with less than 100 drivers. But for a big delivery app? No chance—it’ll break.

Server 2: Adding Redis Pub/Sub

So, I needed a better way. That’s when I brought in Redis Pub/Sub. Redis is this super-fast in-memory store, and its publish-subscribe system is perfect for scaling real-time stuff. Check the code in

2. server (socket + redis pub-sub)/src/websockets/location.gateway.ts. Here’s how I made it work, step-by-step:

2. server (socket + redis pub-sub)/src/websockets/location.gateway.ts

Driver Publishes Location: When the driver sends a send-location event, the server doesn’t broadcast it directly. Instead, it publishes the location to a Redis channel called location-updates. Here’s the code:

   @SubscribeMessage('send-location')
   handleLocation(client: Socket, data: { latitude: number; longitude: number }) {
     const locationData = {
       id: client.id,
       latitude: data.latitude,
       longitude: data.longitude,
     };
     this.pubSubService.publish('location-updates', JSON.stringify(locationData));
   }

Server Subscribes and Targets Updates: The server subscribes to the location-updates channel and sends the update only to specific users using WebSocket rooms. Each driver has a room (named after their ID), and users join that room to track them. Here’s how it’s set up in the constructor:

   constructor(private pubSubService: PubSubService) {
     this.pubSubService.subscribe('location-updates', (message) => {
       const locationData = JSON.parse(message);
       this.server.to(locationData.id).emit('receive-location', locationData);
     });
   }

And when a user wants to track a driver:

   @SubscribeMessage('track-driver')
   handleTrackDriver(client: Socket, driverId: string) {
     client.join(driverId);
   }

Scaling with Multiple Servers: Redis makes this easy. Multiple NestJS servers can subscribe to the same location-updates channel. When a driver’s location is published, all servers get it and send it to the right room. No mess, no fuss.

Why This Is Better

Targeted Updates: Only users tracking a specific driver get their updates. No more flooding everyone with data they don’t need.
Horizontal Scaling: Add more servers, and Redis handles the coordination. Each server manages its own clients, and the load gets shared.

This is a big step up from the basic setup. But I found something even better—keep reading!

Server 3: Redis Streams Adapter for the Win

While Redis Pub/Sub was good, I stumbled upon the Redis Streams Adapter for Socket.IO, and it’s like Pub/Sub ka bada bhai 💀—more powerful and reliable. The code for this is in

3. server (socket + redis streams adapter)/src/redis/redis.module.ts.

3. server (socket + redis streams adapter)/src/redis/redis-io-adapter.ts.

3. server (socket + redis streams adapter)/src/websockets/location.gateway.ts.

Here’s how it works, step-by-step:

Set Up the Adapter: I created a RedisIoAdapter in 3. server (socket + redis streams adapter)/src/redis/redis-io-adapter.ts to use Redis Streams with Socket.IO:

   export class RedisIoAdapter extends IoAdapter {
     private redisClient: Redis;
     constructor(app: INestApplication, redisClient: Redis) {
       super(app);
       this.redisClient = redisClient;
     }
     createIOServer(port: number, options?: ServerOptions): any {
       const server = super.createIOServer(port, options);
       server.adapter(createAdapter(this.redisClient));
       return server;
     }
   }

Driver Sends Location: Same as before—the driver sends a send-location event, and the server emits it to their room:

   @SubscribeMessage('send-location')
   handleLocation(client: Socket, data: { latitude: number; longitude: number }) {
     const locationData = {
       id: client.id,
       latitude: data.latitude,
       longitude: data.longitude,
     };
     this.server.to(client.id).emit('receive-location', locationData);
   }

Users Track Drivers: Users join the driver’s room with a track-driver event:

   @SubscribeMessage('track-driver')
   handleTrackDriver(client: Socket, driverId: string) {
     client.join(driverId);
   }

Magic of Streams: The Redis Streams Adapter handles everything else. It distributes updates across all server instances, ensures no messages are lost, and keeps rooms working seamlessly.

Why This Beats Pub/Sub

Here’s a quick comparison:

Feature	Redis Pub/Sub	Redis Streams Adapter
Reliability	If a server is down, it misses updates.	Stores messages, so servers catch up later.
Scalability	Good for medium loads, but struggles with huge volumes.	Uses consumer groups for big scale.
Message Order	Order isn’t always guaranteed.	Strict order, great for tracking.
Ease of Use	You manage pub/sub yourself.	Socket.IO does it all—less code!

Reliability: If a server crashes with Pub/Sub, it misses updates. With Streams, messages are saved, so nothing gets lost.
Scalability: Streams can handle way more drivers and users with consumer groups splitting the work.
Simplicity: No need to write pub/sub logic—Socket.IO handles it behind the scenes.

This is perfect for a large app with lots of users. But what about massive scale? That’s where Kafka comes in.

Future-Proofing with Kafka

Now, imagine your app grows huge—thousands of drivers, millions of users, and you want to do fancy things like analytics or logging alongside tracking. That’s when Kafka enters the picture. It’s a distributed streaming platform built for handling tons of real-time data.

Here’s the basic plan:

Driver sends location via WebSockets (send-location event).
Server pushes it to a Kafka topic, like driver-locations.
A consumer service reads from the topic and sends updates to users via WebSockets.

Kafka is overkill for small apps, but for enterprise-level scale, it’s a game-changer. I’ll add a Kafka setup to my GitHub repo soon—keep an eye out!

What to Tell Frontend Devs

As a backend dev, I was scratching my head about what to tell the frontend team. Turns out, it’s pretty simple:

Driver App:
- Connect to the WebSocket server.
- Send send-location events with latitude and longitude every few seconds.
- Maybe show the driver’s own location on a map, if needed.
User App:
- Connect to the WebSocket server.
- Listen for receive-location events and update the map.
- Send a track-driver event with the driver’s ID to join their room.

That’s it! The frontend devs will love how easy this is—just a few events, and the backend handles the heavy lifting.

Comparing the Approaches

Let’s break it down with a table to see how these methods stack up:

Approach	Pros	Cons	Best For
Basic WebSockets	Easy to set up, works for small apps.	Not scalable, sends too much data.	Prototypes, small apps.
Redis Pub/Sub	Scales better, targets updates.	Misses updates if servers crash.	Medium-sized apps.
Redis Streams Adapter	Reliable, scalable, less code.	Slightly tricky to set up.	Large apps with many users.
Kafka	Handles huge scale, extra features.	Too much for small apps, needs infra.	Enterprise-level apps.

So, that’s the full story! From a basic prototype to scaling for a real delivery app, this is how you make real-time tracking work. The code’s all on GitHub—go check it out.

Next time you’re waiting for your food and watching that driver dot move, you’ll know what’s happening behind the scenes.

Hope this clears things up—let me know if you have questions!

Ultimate VPS Hosting Guide: Simple Steps for Setup, Optimization, and Production Success

Subham — Sun, 22 Dec 2024 05:54:12 +0000

Setting up a Production Ready VPS is a Lot easier than I thought - Best Guide on How to deploy backend code in production

🔥Connect: https://xam-heisenberg-company.vercel.app/
🔥GitHub: https://github.com/Subham-Maity
🔥Twitter: https://twitter.com/TheSubhamMaity
🔥LinkedIn: https://www.linkedin.com/in/subham-xam
🔥Insta: https://www.instagram.com/subham_xam

Let's be real... Tired of deployment tutorials that leave you hanging? Yeah, me too.

Look, I've noticed something while helping other developers - most guides skip the small but super important steps. You know what happens next? You're stuck with errors at midnight, opening 50 browser tabs trying to figure out what went wrong.

That's why I created this guide. I'll walk you through EVERY single step of deploying your server. Whether you're working with:

Node.js
Go
Spring Boot (Java)
Rust
Django
Laravel
Flask
Or any other server

I'll cover those tiny details that usually trip people up.

Think of this as your friend sitting next to you, helping you deploy your server without pulling your hair out 😅.

Got stuck somewhere? Just comment below or message me directly. I actually answer!

Ready to deploy your server the right way? Let's get started!

1️⃣ First Step - Connect VPS

✅ 1. Choose a Hosting Provider

Purchase a VPS plan from any hosting provider.

✅ 2. Get the Credentials

Whether you're freelancing or working in an office, you'll need three things:

IP address: 568.82.48.166
Username: root
Password: Subham@Xam_08

Example:

568.82.48.166  
root  
Subham@Xam_08

✅ 3. Connect via Terminal

Open your terminal and type:

ssh root@568.82.48.166

✅ 4. Verify the Connection

You'll see a message like this:

The authenticity of host '568.82.48.166 (568.82.48.166)' can't be established.
ED33319 key fingerprint is SHA256:kLP3I9......QgQI.
This key is not known by any other names.

Are you sure you want to continue connecting (yes/no/[fingerprint])?

Just type yes.

✅ 5. Enter the Password

Next, it will prompt:

Warning: Permanently added '568.82.48.166' (ED25519) to the list of known hosts.
root@568.82.48.166's password:

Paste your password (Subham@Xam_08) and press Enter.

(Note: The terminal won't show any characters while typing the password. Just hit Enter.)

✅ 6. Success!

If everything is correct, you'll see:

       Welcome to Ubuntu 54.54.1 LTS (GNU/Linux 8.65.0-424-generic x86_64)

       * Documentation:  https://help.ubuntu.com
       * Management:     https://landscape.canonical.com
       * Support:        https://ubuntu.com/advantage

       System information as of Sat Dec 21 11:56:39 PM UTC 2024

       System load:  0.01555554443125      Processes:               292
       Usage of /:   2.1% of 20000.02GB   Users logged in:         0
       Memory usage: 5%                 IPv4 address for kms160:               568.82.48.166
       Swap usage:   0%

       * Strictly confined Kubernetes makes edge and IoT secure. Learn how MicroK8s
       just raised the bar for easy, resilient and secure K8s cluster deployment.

       https://ubuntu.com/engage/secure-kubernetes-at-the-edge

       137 updates can be applied immediately.
       To see these additional updates run: apt list --upgradable


       *** System restart required ***
       Last login: Mon Dec  9 06:55:53 2024 from 203.145.52.235
       root@ajfaljflaf:~#

What does root@ajfaljflaf:~# mean?

This prompt confirms you are logged in to the server with the hostname ajfaljflaf as the root user. You're now ready to execute commands and set up your server.

2️⃣ Second Step - Ready Your System

✅ 1. Clear the Terminal

Once logged in, type:

    clear

✅ 2. Verify Directories

Check your current directory and list files:

    pwd
    ls

Example output:

    root@hdicj8psx6:~# pwd  
    /root  
    root@hdicj8psx6:~# ls  
    snap

✅ 3. Update the Package List

Refresh the package list to ensure the latest updates:

    sudo apt update

Example output:

    Hit:1 http://archive.ubuntu.com/ubuntu jammy InRelease  
    Get:3 http://archive.ubuntu.com/ubuntu jammy-updates InRelease [128 kB]  
    Ign:4 https://ppa.launchpadcontent.net/certbot/certbot/ubuntu jammy InRelease  
    Err:5 https://ppa.launchpadcontent.net/certbot/certbot/ubuntu jammy Release  
      404  Not Found [IP: 185.125.190.80 443]  
    Reading package lists... Done

If you encounter warnings or errors, review them to ensure they don’t block essential updates.

✅ 4. Upgrade Installed Packages

Install available updates and upgrades:

    sudo apt upgrade

Example prompt:

    124 upgraded, 13 newly installed, 0 to remove, and 0 not upgraded.  
    Need to get 537 MB of archives.  
    After this operation, 679 MB of additional disk space will be used.

Type yes to continue.

✅ 5. Handle Upgrade Prompts

During the upgrade, you may see configuration prompts:

Example 1: Confirm Actions Select "OK" using the Tab key and press Enter:

Example 2: Choose Defaults Select default options or make your changes, then press Enter:

(Note: You need to use tab key for switching the option)

Review Upgrade Completion

Upon successful upgrade, you'll see messages about restarting services:

Restarting services...  
/etc/needrestart/restart.d/systemd-manager  
systemctl restart nginx.service polkit.service ssh.service udisks2.service  
Service restarts being deferred:  
systemctl restart networkd-dispatcher.service  
systemctl restart systemd-logind.service

This confirms that services have been restarted or deferred as necessary.

3️⃣ Third Step - Install Dependencies and Clone Repository with Proper Authentication

✅ 1. Install Node.js

To install Node.js, run:

   sudo apt install nodejs

This will install Node.js.

✅ 2. Install Git

To install Git, run:

   sudo apt install git

✅ 3. Push Your Repository to GitHub

If your code is not already pushed to GitHub, follow these steps on your local machine:

   # 1. Initialize a new Git repository in your project folder
   git init

   # 2. Add all files to the staging area
   git add .
   # Or add specific files
   git add filename.txt

   # 3. Make your first commit
   git commit -m "Initial commit"

   # 4. On GitHub:
   # - Create a new repository
   # - Copy the repository URL (ends with .git)

   # 5. Link your local repo to the GitHub repository
   git remote add origin https://github.com/username/repository.git

   # 6. Push your code to GitHub
   # If using 'main' branch (recommended)
   git push -u origin main

   # If using legacy 'master' branch
   git push -u origin master

Additional Useful Commands:

   # Check repository status
   git status

   # Check remote connection
   git remote -v

   # If you need to rename your branch from master to main
   git branch -M main

Note: If you encounter authentication errors, you need to:

Set up an SSH key.
Use a personal access token instead of a password.
Use GitHub CLI (gh) for authentication.

For guidance, refer to this guide.

✅ 4. Clone the Repository

Copy the HTTPS link from GitHub:

Example:

Clone the repository:

 git clone git@github.com:Subham-Maity/xyz.git

If it's your first time connecting, you'll see a message like this:

   Cloning into 'xyz'...
   The authenticity of host 'github.com (60.404.404.404)' can't be established.
   ED26619 key fingerprint is SHA256:+DiYfsfsfsf....4UvCOqU.
   This key is not known by any other names.
   Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
   Warning: Permanently added 'github.com' (Exxx519) to the list of known hosts.
   git@github.com: Permission denied (publickey).
   fatal: Could not read from remote repository.

   Please make sure you have the correct access rights.

✅ 5. Resolve Authentication Issues

If you encounter the above error, follow these steps:

Install the GitHub CLI (gh):
```
 sudo apt install gh
```

Authenticate with GitHub:

 gh auth login

Follow the prompts:

Choose GitHub.com.
Select HTTPS for the protocol.
Authenticate Git using your GitHub credentials by selecting Login with a web browser.

Example prompts:

 ? What account do you want to log into?  
 > GitHub.com  
 ? What is your preferred protocol for Git operations?  
 > HTTPS  
 Authenticate Git with your GitHub credentials? (Y/n)  
 y  
 ? How would you like to authenticate GitHub CLI?  
 > Login with a web browser  
 ! First copy your one-time code: 40DE-1645  
 - Press Enter to open github.com in your browser...

Copy the one-time code and open the link in your browser.
Log into your GitHub account and paste the code.
Return to your terminal:

   ✓ Authentication complete. Press Enter to continue...
   - gh config set -h github.com git_protocol https
   ✓ Configured git protocol
   ✓ Logged in as Subham-Maity

✅ 6. Add SSH Key to GitHub

Refer to this guide to add your SSH key to GitHub.

✅ 7. Clone the Repository Again

Once the SSH key is added, clone your repository:

   git clone git@github.com:username/repository.git

✅ 8. Verify Cloning

After cloning, check if the repository is present:

ls

4️⃣ Fourth Step - Setup Your Project

✅ 1. Navigate to Your Project Directory

First, list the directories to locate your project:

ls

Then, move into your project folder:

cd <your-project-name>

Tip: Type the first 2-3 letters of your project folder and press the Tab key to auto-complete the name.

✅ 2. Install Project Dependencies

Run the following command inside your project folder to install the necessary packages:

npm i

This might take a few minutes, depending on the size of the project.

✅ 3. Set Up the .env File

If your project doesn’t have a .env file (usually excluded in non-private repositories), you can create one to store your environment variables:

Open a new file named .env in your project directory:

   nano .env

Add your variables in the following format:

   DB_HOST=your-database-host
   DB_USER=your-database-username
   DB_PASSWORD=your-database-password
   PORT=3000
   SECRET_KEY=your-secret-key

Save and exit the editor:
- Press Ctrl + O, then Enter to save.
- Press Ctrl + X to exit.

✅ 4. Verify .env Configuration

Check if your .env file exists and is properly configured:

cat .env

✅ 5. Run the Application

Finally, start your application using:

npm start

OR, if you're using a framework or script, follow its specific command, such as:

npm run dev

Note: If you encounter errors, review the .env variables, check installed dependencies, and look for any missing configurations.

Here’s a rewritten version of the content with better structure, clarity, and formatting:

5️⃣ Fifth Step - Start Your Project

Install PM2

To keep your application running continuously, you can use PM2, a powerful process manager for Node.js applications. It allows for zero-downtime restarts and simplifies DevOps tasks.

Run the following command to install PM2 globally:

npm i -g pm2

Starting Your Application

If you're using NestJS, follow this detailed guide to deploy your NestJS app with PM2:

🔗 Deploy NestJS App Using PM2 on Linux Ubuntu Server

If you're working with a Node.js application, you can refer to this guide:

🔗 How to Start Node.js App with PM2

Once your setup is ready, start your server by typing:

npm start

Open your browser and navigate to:

http://<your-server-IP>:3333/xam

For example:

http://404.89.46.183:3333/xam

📝 Handling Common Issues

⭐ Firewall Blocking Your Site

If the server isn’t accessible, it might be due to a firewall issue. First, verify the firewall rules with:

sudo iptables -L

This command lists all current firewall rules. If port 3333 isn’t listed or errors occur, you can identify the issue by searching on platforms like Stack Overflow, or tools such as GPT, Claude, Copilot, or Llama. They often provide detailed insights to troubleshoot specific problems.

⭐ Updating Firewall Rules

If the firewall blocks incoming traffic on port 3333, update the rules with:

sudo iptables -A INPUT -p tcp --dport 3333 -j ACCEPT

Command Breakdown:
-A INPUT: Append a rule to the INPUT chain.
-p tcp: Specify the TCP protocol.
--dport 3333: Define port 3333.
-j ACCEPT: Allow traffic on this port.

Now verify the updated rules:

sudo iptables -L

You should see something like this:

ACCEPT     tcp  --  anywhere             anywhere             tcp dpt:3333

⭐ Persisting Firewall Rules

To ensure the firewall rules remain after a reboot, install the netfilter-persistent package:

sudo apt install netfilter-persistent

Save the rules with:

sudo netfilter-persistent save

⭐ Managing PM2 Processes

Start Your Application with PM2

Use the following command to start your server with PM2:
```
   pm2 start dist/main.js --name server -f
```
The -f flag forces PM2 to restart the process.
Delete Unused Processes

If there are processes from previous runs, you can delete them using their IDs:

   pm2 delete 0
   pm2 delete 1

This ensures no conflicts occur with duplicate processes.

6️⃣ Sixth Step - Point Your Domain to the Server

✅ 1. Buy a Domain

Purchase a domain from a trusted provider like:

GoDaddy
Namecheap
Google Domains

✅ 2. Log in to Your Domain Provider

Access Your Account

Log in to your domain provider’s website using your credentials.
Navigate to Domain Settings

Find the domain you want to point to your server and locate the DNS settings or DNS management section.
Update DNS Records
- Look for the option to add or edit DNS records.
- If prompted, set the nameservers to your hosting provider’s nameservers. (Nameservers act like the internet’s phone book. When you type a domain name into your browser, nameservers tell your computer where to find the website.)

✅ 3. Add an A Record

To point your domain to your server, add an A record with the following details:

Type: A
Name: @ or your domain name (e.g., xyz.com)
Points to: Your server’s IP address (e.g., 222.22.22.222)
TTL: 1 hour (or the default value)

Example:

✅ 4. Verify DNS Propagation

To check if the DNS changes have taken effect, open a terminal and run:

nslookup yourdomain.com

Example output:

> nslookup xyz.com
Server:  WowWOW
Address:  222.222.222.222

Non-authoritative answer:
Name:    xyz.com
Address:  222.222.222.222

Note: DNS changes can take up to 24 hours to propagate globally. Be patient!

7️⃣ Seventh Step - Install and Configure Nginx

✅ 1. Install Nginx

Nginx is a high-performance web server that can act as a reverse proxy, load balancer, and HTTP cache. Install it using:

sudo apt install nginx

✅ 2. Navigate to Nginx Configuration

Go to the Nginx configuration directory:

   cd /etc/nginx

List the files to familiarize yourself with the structure:

ls

Example output:

   conf.d  fastcgi.conf  fastcgi_params  koi-utf  koi-win  mime.types  modules-available  modules-enabled  nginx.conf  proxy_params  scgi_params  sites-available  sites-enabled  snippets  uwsgi_params  win-utf

✅ 3. Edit the Default Configuration

Open the default configuration file in a text editor (e.g., vim):

   sudo vim /etc/nginx/sites-available/default

Locate the server_name directive and update it with your domain:

   server_name xyz.com www.xyz.com;

Example:

Scroll down to the location / block and replace it with the following:

   location / {
       proxy_pass http://localhost:3333;  # Replace with your app's port
       proxy_http_version 1.1;
       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection 'upgrade';
       proxy_set_header Host $host;
       proxy_cache_bypass $http_upgrade;
   }

✅ 4. Test and Restart Nginx

Test the Nginx configuration to ensure there are no syntax errors:

   sudo nginx -t

Expected output:

  ```text
  nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
  nginx: configuration file /etc/nginx/nginx.conf test is successful
 ```

Restart Nginx to apply the changes:

   sudo nginx -s reload

✅ 5. Verify Your Setup

Open your browser and navigate to your domain (e.g., http://xyz.com). You should see your application running!

📝 Troubleshooting Tips

Firewall Issues: Ensure port 80 (HTTP) and 443 (HTTPS) are open in your firewall. Use:

  sudo ufw allow 80
  sudo ufw allow 443

Nginx Errors: Check the Nginx error logs for details:

  sudo tail -f /var/log/nginx/error.log

8️⃣ Eighth Step - Install SSL Certificate with Certbot

✅ 1. Install Certbot

Certbot is a free, open-source tool that automates the installation and renewal of SSL certificates. To install Certbot, follow these steps:

Add the Certbot repository:

   sudo add-apt-repository ppa:certbot/certbot

Press Enter to confirm.

Update your package list:

   sudo apt-get update

Install Certbot for Nginx:

   sudo apt-get install python3-certbot-nginx

✅ 2. Generate an SSL Certificate

Once Certbot is installed, you can generate an SSL certificate for your domain. Run the following command:

sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

Replace yourdomain.com with your actual domain name.
If you have subdomains, you can add them using additional -d flags (e.g., -d subdomain.yourdomain.com).

Example:

sudo certbot --nginx -d xyz.com -d www.xyz.com -d api.xyz.com

Certbot will automatically configure Nginx to use the SSL certificate and redirect HTTP traffic to HTTPS.

✅ 3. Verify SSL Installation

After the process completes, open your browser and visit:

https://yourdomain.com

You should see a padlock icon in the address bar, indicating that your site is secured with SSL.

✅ 4. Automate Certificate Renewal

Certbot certificates are valid for 90 days. To ensure your certificate is renewed automatically, Certbot sets up a cron job or systemd timer. However, you can manually test the renewal process with:

sudo certbot renew --dry-run

This command simulates the renewal process and ensures everything is working correctly. If the test is successful, Certbot will automatically renew your certificates before they expire.

📝 Troubleshooting Tips

Firewall Configuration: Ensure ports 80 (HTTP) and 443 (HTTPS) are open in your firewall:

  sudo ufw allow 80
  sudo ufw allow 443

Nginx Configuration Errors: If Certbot fails to configure Nginx, check the Nginx error logs:

  sudo tail -f /var/log/nginx/error.log

Certificate Not Working? If your site doesn’t load over HTTPS, verify that the SSL certificate is correctly installed:

  sudo certbot certificates

Now your website is secured with an SSL certificate, and Certbot will handle renewals automatically. Enjoy a safer and more professional web presence! 🔒🎉

================================If you want to go with AlmaLinux=================

AlmaLinux VPS Setup Guide

⚠️ AlmaLinux Note: AlmaLinux is RHEL-based. It uses dnf instead of apt, firewalld instead of ufw/iptables, and packages are sourced from EPEL and other RHEL-compatible repos.

1️⃣ First Step - Connect VPS

✅ 1. Choose a Hosting Provider
Purchase a VPS plan from any hosting provider.

✅ 2. Get the Credentials
Whether you're freelancing or working in an office, you'll need three things:

IP address: 568.82.48.166
Username: root
Password: Subham@Xam_08

Example:

568.82.48.166
root
Subham@Xam_08

✅ 3. Connect via Terminal
Open your terminal and type:

ssh root@568.82.48.166

✅ 4. Verify the Connection
You'll see a message like this:

The authenticity of host '568.82.48.166 (568.82.48.166)' can't be established.
ED25519 key fingerprint is SHA256:kLP3I9......QgQI.
This key is not known by any other names.

Are you sure you want to continue connecting (yes/no/[fingerprint])?

Just type yes.

✅ 5. Enter the Password
Next, it will prompt:

Warning: Permanently added '568.82.48.166' (ED25519) to the list of known hosts.
root@568.82.48.166's password:

Paste your password (Subham@Xam_08) and press Enter.
(Note: The terminal won't show any characters while typing the password. Just hit Enter.)

✅ 6. Success!
If everything is correct, you'll see:

       Welcome to AlmaLinux 9.x (Midnight Oncilla)

       * Documentation:  https://wiki.almalinux.org
       * AlmaLinux OS:   https://almalinux.org

       System information as of Sat Dec 21 11:56:39 PM UTC 2024

       System load:  0.01       Processes:             292
       Usage of /:   2.1%       Users logged in:       0
       Memory usage: 5%         IPv4 address for eth0: 568.82.48.166
       Swap usage:   0%

       Last login: Mon Dec  9 06:55:53 2024 from 203.145.52.235
       [root@ajfaljflaf ~]#

What does [root@ajfaljflaf ~]# mean?
This prompt confirms you are logged in to the server with the hostname ajfaljflaf as the root user. You're now ready to execute commands and set up your server.

2️⃣ Second Step - Ready Your System

✅ 1. Clear the Terminal
Once logged in, type:

clear

✅ 2. Verify Directories
Check your current directory and list files:

pwd
ls

Example output:

[root@hdicj8psx6 ~]# pwd
/root
[root@hdicj8psx6 ~]# ls

✅ 3. Enable EPEL Repository
AlmaLinux relies on EPEL (Extra Packages for Enterprise Linux) for many packages. Enable it first:

sudo dnf install -y epel-release

✅ 4. Update the Package List
Refresh the package metadata to ensure the latest updates:

sudo dnf check-update

(This is the AlmaLinux equivalent of apt update. It's okay if it exits with code 100 — that just means updates are available.)

✅ 5. Upgrade Installed Packages
Install available updates and upgrades:

sudo dnf upgrade -y

Example output:

Upgraded:
  bash-5.1.8-6.el9.x86_64
  ...
Complete!

✅ 6. Handle Upgrade Prompts
During the upgrade, dnf may ask you to confirm GPG keys for new repositories. Type y and press Enter to accept.

Upon successful upgrade, services may need a restart. You can reboot if prompted:

sudo reboot

Then SSH back in after the reboot completes.

3️⃣ Third Step - Install Dependencies and Clone Repository with Proper Authentication

✅ 1. Install Node.js
AlmaLinux's default Node.js version may be outdated. Use the NodeSource repository to get a current LTS version:

# Add NodeSource repo for Node.js 20 LTS
curl -fsSL https://rpm.nodesource.com/setup_20.x | sudo bash -

# Install Node.js
sudo dnf install -y nodejs

Verify installation:

node -v
npm -v

✅ 2. Install Git
To install Git, run:

sudo dnf install -y git

✅ 3. Push Your Repository to GitHub
If your code is not already pushed to GitHub, follow these steps on your local machine:

# 1. Initialize a new Git repository in your project folder
git init

# 2. Add all files to the staging area
git add .
# Or add specific files
git add filename.txt

# 3. Make your first commit
git commit -m "Initial commit"

# 4. On GitHub:
# - Create a new repository
# - Copy the repository URL (ends with .git)

# 5. Link your local repo to the GitHub repository
git remote add origin https://github.com/username/repository.git

# 6. Push your code to GitHub
# If using 'main' branch (recommended)
git push -u origin main

# If using legacy 'master' branch
git push -u origin master

Additional Useful Commands:

# Check repository status
git status

# Check remote connection
git remote -v

# If you need to rename your branch from master to main
git branch -M main

Note: If you encounter authentication errors, you need to:

Set up an SSH key.
Use a personal access token instead of a password.
Use GitHub CLI (gh) for authentication.

For guidance, refer to this guide.

✅ 4. Clone the Repository
Clone the repository using SSH:

git clone git@github.com:username/repository.git

If it's your first time connecting, you'll see an authenticity prompt. Type yes to continue.

✅ 5. Resolve Authentication Issues
If you encounter a Permission denied (publickey) error, install GitHub CLI:

# Add the GitHub CLI repository for AlmaLinux/RHEL
sudo dnf install -y 'dnf-command(config-manager)'
sudo dnf config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo

# Install GitHub CLI
sudo dnf install -y gh

Authenticate with GitHub:

gh auth login

Follow the prompts:

Choose GitHub.com.
Select HTTPS for the protocol.
Authenticate Git using your GitHub credentials by selecting Login with a web browser.

Example prompts:

? What account do you want to log into?
> GitHub.com
? What is your preferred protocol for Git operations?
> HTTPS
Authenticate Git with your GitHub credentials? (Y/n)
y
? How would you like to authenticate GitHub CLI?
> Login with a web browser
! First copy your one-time code: 40DE-1645
- Press Enter to open github.com in your browser...

Copy the one-time code and open the link in your browser.
Log into your GitHub account and paste the code.
Return to your terminal:

  ✓ Authentication complete. Press Enter to continue...
  - gh config set -h github.com git_protocol https
  ✓ Configured git protocol
  ✓ Logged in as Subham-Maity

✅ 6. Add SSH Key to GitHub
Refer to this guide to add your SSH key to GitHub.

✅ 7. Clone the Repository Again
Once the SSH key is added, clone your repository:

git clone git@github.com:username/repository.git

✅ 8. Verify Cloning
After cloning, check if the repository is present:

ls

4️⃣ Fourth Step - Setup Your Project

✅ 1. Navigate to Your Project Directory
First, list the directories to locate your project:

ls

Then, move into your project folder:

cd <your-project-name>

Tip: Type the first 2-3 letters of your project folder and press the Tab key to auto-complete the name.

✅ 2. Install Project Dependencies
Run the following command inside your project folder to install the necessary packages:

npm i

This might take a few minutes, depending on the size of the project.

✅ 3. Set Up the .env File
If your project doesn't have a .env file (usually excluded in non-private repositories), you can create one to store your environment variables.

Install nano if it's not already available:

sudo dnf install -y nano

Open a new file named .env in your project directory:

nano .env

Add your variables in the following format:

DB_HOST=your-database-host
DB_USER=your-database-username
DB_PASSWORD=your-database-password
PORT=3000
SECRET_KEY=your-secret-key

Save and exit the editor:

Press Ctrl + O, then Enter to save.
Press Ctrl + X to exit.

✅ 4. Verify .env Configuration
Check if your .env file exists and is properly configured:

cat .env

✅ 5. Run the Application
Finally, start your application using:

npm start

OR, if you're using a framework or script, follow its specific command, such as:

npm run dev

Note: If you encounter errors, review the .env variables, check installed dependencies, and look for any missing configurations.

5️⃣ Fifth Step - Start Your Project

Install PM2

To keep your application running continuously, you can use PM2, a powerful process manager for Node.js applications. It allows for zero-downtime restarts and simplifies DevOps tasks.

Run the following command to install PM2 globally:

npm i -g pm2

Starting Your Application

If you're using NestJS, follow this detailed guide to deploy your NestJS app with PM2:
🔗 Deploy NestJS App Using PM2 on Linux Ubuntu Server

If you're working with a Node.js application, you can refer to this guide:
🔗 How to Start Node.js App with PM2

Once your setup is ready, start your server:

npm start

Open your browser and navigate to:

http://<your-server-IP>:3333/xam

For example:
http://404.89.46.183:3333/xam

📝 Handling Common Issues

⭐ Firewall Blocking Your Site

AlmaLinux uses firewalld instead of iptables or ufw. First, check the firewall status:

sudo firewall-cmd --state
sudo firewall-cmd --list-all

This lists all current active firewall rules. If port 3333 isn't listed, it is being blocked.

⭐ Updating Firewall Rules

To allow incoming traffic on port 3333, run:

sudo firewall-cmd --permanent --add-port=3333/tcp
sudo firewall-cmd --reload

Command Breakdown:

--permanent: Makes the rule persist across reboots.
--add-port=3333/tcp: Opens TCP port 3333.
--reload: Applies the new rules immediately.

Verify the updated rules:

sudo firewall-cmd --list-ports

You should see:

3333/tcp

⭐ Persisting Firewall Rules

The --permanent flag already ensures rules survive a reboot. To double-check, simply run:

sudo firewall-cmd --list-all --permanent

No additional packages are needed — firewalld handles persistence natively on AlmaLinux.

⭐ Managing PM2 Processes

Start Your Application with PM2 Use the following command to start your server with PM2:

   pm2 start dist/main.js --name server -f

The -f flag forces PM2 to restart the process.

Delete Unused Processes If there are processes from previous runs, you can delete them using their IDs:

   pm2 delete 0
   pm2 delete 1

This ensures no conflicts occur with duplicate processes.

Enable PM2 on System Boot On AlmaLinux, run this to auto-start PM2 after reboot:

   pm2 startup

Copy and run the command it outputs, then save the process list:

   pm2 save

6️⃣ Sixth Step - Point Your Domain to the Server

✅ 1. Buy a Domain

Purchase a domain from a trusted provider like:

GoDaddy
Namecheap
Google Domains

✅ 2. Log in to Your Domain Provider

Access Your Account
Log in to your domain provider's website using your credentials.
Navigate to Domain Settings
Find the domain you want to point to your server and locate the DNS settings or DNS management section.
Update DNS Records
- Look for the option to add or edit DNS records.
- If prompted, set the nameservers to your hosting provider's nameservers. (Nameservers act like the internet's phone book. When you type a domain name into your browser, nameservers tell your computer where to find the website.)

✅ 3. Add an A Record

To point your domain to your server, add an A record with the following details:

Type: A
Name: @ or your domain name (e.g., xyz.com)
Points to: Your server's IP address (e.g., 222.22.22.222)
TTL: 1 hour (or the default value)

✅ 4. Verify DNS Propagation

To check if the DNS changes have taken effect, open a terminal and run:

nslookup yourdomain.com

Example output:

Server:  WowWOW
Address:  222.222.222.222

Non-authoritative answer:
Name:    xyz.com
Address:  222.222.222.222

Note: DNS changes can take up to 24 hours to propagate globally. Be patient!

7️⃣ Seventh Step - Install and Configure Nginx

✅ 1. Install Nginx

Nginx is available directly via dnf on AlmaLinux:

sudo dnf install -y nginx

Enable and start Nginx so it runs on boot:

sudo systemctl enable nginx
sudo systemctl start nginx

Also allow HTTP/HTTPS traffic through the firewall:

sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --reload

✅ 2. Navigate to Nginx Configuration

Go to the Nginx configuration directory:

   cd /etc/nginx

List the files to familiarize yourself with the structure:

ls

Example output:

   conf.d  fastcgi.conf  fastcgi_params  mime.types  modules  nginx.conf  scgi_params  uwsgi_params

AlmaLinux Note: Unlike Ubuntu, AlmaLinux's Nginx uses /etc/nginx/conf.d/ for site configs instead of sites-available/sites-enabled. You'll create a new config file there.

✅ 3. Create a Server Block Configuration

Instead of editing a default file, create a new config file for your domain:

sudo vim /etc/nginx/conf.d/xyz.conf

Add the following content (replace xyz.com and port 3333 as needed):

server {
    listen 80;
    server_name xyz.com www.xyz.com;

    location / {
        proxy_pass http://localhost:3333;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Save and exit:

Press Esc, then type :wq and press Enter.

✅ 4. Handle SELinux (AlmaLinux Specific)

AlmaLinux enables SELinux by default, which may block Nginx from connecting to your app. Run this to allow it:

sudo setsebool -P httpd_can_network_connect 1

✅ 5. Test and Restart Nginx

Test the Nginx configuration to ensure there are no syntax errors:

   sudo nginx -t

Expected output:

   nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
   nginx: configuration file /etc/nginx/nginx.conf test is successful

Reload Nginx to apply the changes:

   sudo systemctl reload nginx

✅ 6. Verify Your Setup

Open your browser and navigate to your domain (e.g., http://xyz.com). You should see your application running!

📝 Troubleshooting Tips

Firewall Issues: Ensure ports 80 (HTTP) and 443 (HTTPS) are open:

  sudo firewall-cmd --permanent --add-service=http
  sudo firewall-cmd --permanent --add-service=https
  sudo firewall-cmd --reload

Nginx Errors: Check the Nginx error logs for details:

  sudo tail -f /var/log/nginx/error.log

SELinux Denials: If Nginx still can't proxy, check SELinux audit logs:

  sudo ausearch -c 'nginx' --raw | audit2allow -M nginx-policy
  sudo semodule -i nginx-policy.pp

8️⃣ Eighth Step - Install SSL Certificate with Certbot

✅ 1. Install Certbot

On AlmaLinux, Certbot is available via EPEL (make sure you enabled it in Step 2):

# Install Certbot and the Nginx plugin
sudo dnf install -y certbot python3-certbot-nginx

Note: Do NOT use add-apt-repository — that is a Debian/Ubuntu command. On AlmaLinux, EPEL is sufficient.

✅ 2. Generate an SSL Certificate

Once Certbot is installed, generate an SSL certificate for your domain:

sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

Replace yourdomain.com with your actual domain name.
Add subdomains using additional -d flags if needed.

Example:

sudo certbot --nginx -d xyz.com -d www.xyz.com -d api.xyz.com

Certbot will automatically configure Nginx to use the SSL certificate and redirect HTTP traffic to HTTPS.

✅ 3. Verify SSL Installation

After the process completes, open your browser and visit:

https://yourdomain.com

You should see a padlock icon in the address bar, indicating that your site is secured with SSL.

✅ 4. Automate Certificate Renewal

Certbot certificates are valid for 90 days. On AlmaLinux, Certbot installs a systemd timer for auto-renewal. Verify it is active:

sudo systemctl status certbot-renew.timer

You can also manually test the renewal process with:

sudo certbot renew --dry-run

This command simulates the renewal process and ensures everything is working correctly.

📝 Troubleshooting Tips

Firewall Configuration: Ensure ports 80 and 443 are open:

  sudo firewall-cmd --permanent --add-service=http
  sudo firewall-cmd --permanent --add-service=https
  sudo firewall-cmd --reload

Nginx Configuration Errors: If Certbot fails to configure Nginx, check the error logs:

  sudo tail -f /var/log/nginx/error.log

Certificate Not Working? Verify that the SSL certificate is correctly installed:

  sudo certbot certificates

SELinux blocking HTTPS? Re-run the SELinux fix:

  sudo setsebool -P httpd_can_network_connect 1

🔑 Quick Reference: Ubuntu vs AlmaLinux Commands

Task	Ubuntu Command	AlmaLinux Command
Update package list	`apt update`	`dnf check-update`
Upgrade packages	`apt upgrade`	`dnf upgrade`
Install a package	`apt install <pkg>`	`dnf install <pkg>`
Enable EPEL	N/A	`dnf install epel-release`
Allow firewall port	`ufw allow 3333`	`firewall-cmd --permanent --add-port=3333/tcp && firewall-cmd --reload`
Allow HTTP/HTTPS	`ufw allow 80/443`	`firewall-cmd --permanent --add-service=http`
Persist firewall rules	`netfilter-persistent save`	Built-in with `--permanent` flag
Install Certbot	`apt install python3-certbot-nginx`	`dnf install certbot python3-certbot-nginx`
Add repo	`add-apt-repository ppa:...`	`dnf config-manager --add-repo <url>`
Nginx sites config	`/etc/nginx/sites-available/`	`/etc/nginx/conf.d/`
Enable service on boot	Automatic	`systemctl enable <service>`

OOPS in JAVA - Ultimate

Subham — Mon, 04 Nov 2024 05:35:21 +0000

🔥Repo: https://github.com/Subham-Maity/Object-Oriented-Programming-For-Beginners

🔥Connect: https://xam-heisenberg-company.vercel.app/
🔥GitHub: https://github.com/Subham-Maity
🔥Twitter: https://twitter.com/TheSubhamMaity
🔥LinkedIn: https://www.linkedin.com/in/subham-xam
🔥Insta: https://www.instagram.com/subham_xam

✅ Looking for the best notes on OOP concepts in JS? Here’s one for you:

> "OOPS in JS - Ultimate" - Check This

I originally put these notes together back in college, so if you’re working through OOP concepts in Java, they might save you some time. Thought I'd share in case it helps anyone out feel free to check them out!

👉🏽 Extra Notes

⭐ Revision and Quick Short Notes for Interview
🤔 Why Java Platform Independent

👉🏽 Start here

📝 Introduction to Object-Oriented Programming
🧰 Basic Terminologies
🛠️ Creating Our Own Java Class
📖 Chapter 1 - Question-Answer Practice Set
🔐 Access Modifiers, Getters & Setters
🔨 Constructors in Java
📘 Chapter 2 - Question-Answer Practice Set
🧬 Inheritance Overview in Java
🌐 Types of Inheritance
🔄 Constructors in Inheritance
🚀 Method & Method Overloading, Void Keyword
- 🔸 Syntax of a method
- 🔸 Method returns the sum of two numbers
- 🔸 Calling a Method
- 🔸 Process of method invocation
- 🔸 Overloaded function foo
- 🔸 Method overloading Type 1 - By changing the return type
- 🔸 Method overloading Type 1 - By changing the number of arguments passed
- 🔸 Can we overload java main() method
- 🔸 Method Overloading and Type Promotion
📏 Static Keyword
- 🔸 Java Static Variable
- 🔸 With Static Variable
- 🔸 Restriction on Static method
- 🔸 Static Method
- 🔸 Static block
- 🔸 Static Class
🔢 Variable Arguments (VarArgs)
🔁 this & super Keyword
- 🔸 Without This Keyword
- 🔸 With This Keyword
- 🔸 Without Super Keyword
- 🔸 With Super Keyword
🧩 Method Overriding
- 🔸 Without Method Overridin
- 🔸 With Method Overriding
🔄 Overloading and Overriding
📊 Dynamic Method Dispatch
📗 Chapter 3 - Question-Answer Practice Set
🧾 Quick One Question-Answer on Chapter 1, 2 & 3
🔍 Abstract Class & Abstract Methods
🖇️ Introduction to Interfaces
⚖️ Abstract Classes Vs Interfaces
🚫 Why Multiple Inheritance is Not Supported in Java
- 🔸 Try to implement Multiple Inheritance
- 🔸 Multiple Inheritance Using Interface
⚙️ Java Interfaces Example & Default Methods
🏗️ Inheritance in Interfaces
🔀 Polymorphism Concept in Interfaces
📙 Chapter 4 - Question-Answer Practice Set
📝 College Level Q&A on Chapters 1, 2, 3 & 4
🛠️ Projects on Chapters 3 & 4 (Basic & Advance)
💻 Interpreted vs Compiled Languages
📂 Is Java Interpreted or Compiled?
⚙️ Java File Compilation Process
📦 Packages in Java
🛠️ Creating a Custom Package
🔓 Access Modifiers Experiment
- 🔸 AccessModifier
- 🔸 OutSidePackageExperiment
- 🔸 OutSidePackageSubclassExperiment
📘 Chapter 5 - Question-Answer Practice Set
🧾 Quick One Question-Answer on Chapter 5
📘 Wrapper Classes in Java
- 🔸 Converting int to Integer (Primitive to Wrapper)
- 🔸 Converting Integer to int (Wrapper to Primitive)
- 🔸 Autoboxing (Detailed Explanation)
- 🔸 Unboxing (Detailed Explanation)
- 🔸 Demonstrate Wrapping and Unwrapping
🔗 Constructor Chaining in Java
- 🔸 Using Super Keyword in Another Class
- 🔸 Using This Keyword in the Same Class
🔐 Private Constructors and Singleton Classes
- 🔸 Using Private Constructors in Singleton Pattern
- 🔸 Example
🔄 Types of Polymorphism
- 🔸 Compile-time Polymorphism
- 🔸 Run-time Polymorphism
🛡️ Encapsulation Idea
- 🔸 Java Encapsulation
- 🔸 Data Hiding
🔍 Nested Interface in Java
⚙️ Modifiers Types

Is Redux Dead? Why I Kicked Redux Out of Our SaaS App

Subham — Tue, 15 Oct 2024 21:54:19 +0000

🔥Connect: https://xam-heisenberg-company.vercel.app/
🔥GitHub: https://github.com/Subham-Maity
🔥Twitter: https://twitter.com/TheSubhamMaity
🔥LinkedIn: https://www.linkedin.com/in/subham-xam
🔥Insta: https://www.instagram.com/subham_xam

A few months ago, I took the plunge and refactored parts of a SaaS app I’ve been working on for a while. We had Redux in there, doing its thing, managing global state. Even with the newer RTK Query approach, which streamlines Redux’s handling of server state, we found ourselves gravitating toward React Query for its straightforward setup and reduced boilerplate... You know, like when you carry around stuff in your backpack that you haven’t touched in months? That’s how it felt.
But as our app grew, so did the complexity. Redux started to feel less like a solution and more like a problem. We were writing more boilerplate than actual logic.

💡 The Redux Dilemma

One day, while battling yet another Redux-related bug, I stumbled upon React Query. I'd heard a lot of buzz around it, but I never thought it could completely replace Redux. Then I gave it a try.

Before (with Redux):

import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'

export const api = createApi({
  baseQuery: fetchBaseQuery({ baseUrl: '/api' }),
  endpoints: (builder) => ({
    getUser: builder.query({
      query: (userId) => `users/${userId}`,
    }),
  }),
})

// Component with RTK Query
const UserProfile = ({ userId }) => {
  const { data, isLoading, error } = api.useGetUserQuery(userId);

  if (isLoading) return <Spinner />;
  if (error) return <Error message={error.message} />;
  return <UserInfo user={data} />;
};

After (with React Query):

const useUserData = (userId) => {
  return useQuery(['user', userId], () => api.fetchUser(userId));
};

const UserProfile = ({ userId }) => {
  const { data, isLoading, error } = useUserData(userId);

  if (isLoading) return <Spinner />;
  if (error) return <Error message={error.message} />;
  return <UserInfo user={data} />;
};

While both approaches might look similar in this simple example, React Query's simplicity shows in real-world applications. It doesn't require setting up stores or managing additional architectural patterns - it just works out of the box while giving you powerful caching and state management capabilities.

Instead of manually fetching data, writing reducers, dispatching actions, and then updating the store (old pattern of redux), React Query did most of that heavy lifting for us. Pair that with some well-crafted custom hooks, and we had a lean, mean state-management machine.

🤔 But Wait, Is Redux All Bad?

Now, don't get me wrong. Redux isn't the boogeyman. It's a powerful tool that has its place. If you're building an app with complex client-side state that needs to be shared across many unrelated components, If you’re working with deeply nested state, or if you need a more explicit control over the flow of your app but for 90% of cases, especially for handling server state, React Query + custom hooks is more than enough.

So, why the fuss? Sometimes, as devs, we fall into the trap of using what’s familiar, even when there are better tools out there. That’s what happened with me and Redux. I was stuck in my old ways, thinking Redux was the only way to manage state in larger apps. I mean, the whole internet was saying “Redux or bust!” right?

🎭 The Plot Twist

Here's the kicker: by choosing React Query over Redux (even modern Redux), we actually made our app MORE scalable. Counter-intuitive, right? But think about it – with React Query handling our server state and custom hooks managing local state, we had a clearer separation of concerns. Each part of our app became more modular and easier to reason about, without the overhead of Redux's architecture.

✅ Why We Still Choose React Query

Simplicity: React Query required fewer configurations and dependencies, allowing us to start quickly and avoid setup time.
- You need to include Redux as a dependency
- You need to set up Redux store configuration
- It's integrated with Redux's architecture
Bundle Size: When you only need server state management, React Query offers a lighter solution since you don't need to include the entire Redux ecosystem
Flexibility: With React Query, managing server state felt more intuitive, especially for small, isolated pieces of server data.
Learning Curve: For teams not already using Redux, React Query often provides a gentler learning curve

🚀 Why This Approach is Correct:

RTK Query was developed to bridge the gap between Redux and modern server state tools like React Query. However, for server state management, React Query remains a more streamlined choice, offering specialized features for caching, background updates, and retries without Redux’s added setup. For global client state, you can combine React Query with lightweight libraries like Zustand or even use React's Context API. This approach avoids Redux’s heavier infrastructure, keeping your application’s state management both simpler and more performant by focusing React Query on server state and relying on lighter options for global client state.

🏁 Is Redux dead?

Honestly, in the last few months, I’ve seen very few cases where React Query didn’t meet my needs.

So, is Redux dead? Maybe not, but it's definitely not the all-star it used to be for handling server state in modern React apps.

The beauty of React Query lies in its focused approach to solving server state challenges without the additional complexity of a global state management system.

It's not about Redux being bad - it's about choosing the right tool for the job. In our case, React Query proved to be that tool. React Query bring a new level of simplicity and efficiency that’s hard to ignore. For those not tied to Redux, it might be worth exploring if React Query or other dedicated server state solutions could better meet your app’s needs."

So, there you have it. Our journey from Redux addiction to React Query enlightenment. It wasn't always easy – there were moments of doubt, late-night debugging sessions, and more than a few facepalms. But in the end, it was worth it.

The key isn't choosing what's popular or traditional - it's choosing what's right for your specific needs. For us, that was React Query, and we haven't looked back since.

If you're feeling bogged down by Redux in your own app, I encourage you to take a step back and ask yourself: do you really need it? You might be surprised by the answer.

sometimes less is more. Especially when it comes to state management. Now if you'll excuse me, I have some more reducers to delete. Happy coding!

You can also check: Learn RTK Query

OOPS in JS - Ultimate

Subham — Mon, 23 Sep 2024 23:25:10 +0000

🔥Connect: https://xam-heisenberg-company.vercel.app/
🔥GitHub: https://github.com/Subham-Maity
🔥Twitter: https://twitter.com/TheSubhamMaity
🔥LinkedIn: https://www.linkedin.com/in/subham-xam
🔥Insta: https://www.instagram.com/subham_xam

✅ Looking for the best notes on OOP concepts in JAVA? Here’s one for you:

> "OOPS in JAVA - Ultimate" - Check This

▶️ Intro

⭐ What is OOPs ?

Object-oriented programming is an approach to solving problems by creating objects .

⭐ 4 Pillars of OOP

Terminologies in OOP

Abstraction - Hiding internal details (show only essential info!)
Encapsulation - The act of putting various components together (in a capsule)
Inheritance - The act of deriving new things from existing things
Polymorphism - One entity, many forms

▶️ Prototypes and proto

JavaScript's objects have a special property called prototype that is either null or references another object

When we try to read a property from an object, and it's missing, JavaScript automatically takes it from the prototype. This is called prototype inheritance

⭐ Setting a Prototype

We can set the prototype by setting __proto__. If we read a property from an object that is not in the object but is present in the prototype, JavaScript will take it from the prototype. If we have a method in the object, it will be called from the object. If it's missing in the object and present in the prototype, it will be called from the prototype.

⭐ Example:

//It will work properly
let p = {
    run : () => {
        console.log("run")
    }
}

p.run()//Output: - run

//Let's define another property
let a = {
    name : " subham"
}

a.run() //TypeError: a.run is not a function

//Now with proto
let b = {
    name : " subham"
}
b.__proto__ = p
b.run() //Output: - run

Simply, you can inherit some object’s prototype in another object. This is called prototype inheritance.

//It will work properly
let p = {
    run : () => {
        console.log("p run")
    }
}

p.run()//Output: - p run

//Now with proto
let b = {
    run : () => {
        console.log("b run")
    }
}
b.__proto__ = p
b.run() //Output: - b run

If a property or method is already present in the object, JavaScript will use that property or method. If it's not present in the object but is present in the prototype, JavaScript will take it from the prototype. In this example, since the run method is already present in the b object, it will print 'b run'.

▶️ Classes and Object

In object-oriented programming, a class is a template definition of the methods and variables in a particular kind of object
In object-oriented programming, an object is a specific instance of a class (or struct) which has been allocated in memory.

⭐ Example:

//class
class GoogleForm {
    submit() {
       console.log(this.name + " " + this.roll + " Your form submitted")
    }
    cancel() {
        console.log(this.name + " " + this.roll +" Your form cancelled")
    }
    fill(given_name , roll) {
        this.name = given_name
        this.roll = roll
    }
}


//object
const student1Form = new GoogleForm()

student1Form.fill("Rahul" , 24)

const student2Form = new GoogleForm()

student2Form.fill("Raj" , 25)

student2Form.cancel()


student1Form.submit()

student2Form.submit()

▶️ Constructor

In JavaScript, a constructor is a special function that creates and initializes objects, setting their initial state and properties.

Let's say they forget to fill the form and click on the submit button it will throw undefined!

class Form {

    submit() {
        console.log(this.name + ": Your form is submitted for train number: " + this.trainno)
    }

    cancel() {
        console.log(this.name + ": This form is cancelled for train number: " + this.trainno)
        this.trainno = 0
    }
    fill(givenname, trainno) {
        this.name = givenname
        this.trainno = trainno
    }

}

let myForm1 = new Form()

let myForm2 = new Form()
//
// myForm1.fill("Gaurav", 1234)
//
// myForm2.fill("Rahul", 5678)

myForm1.submit()

myForm2.submit()

myForm2.cancel()

// Output: undefined: Your form is submitted for train number: undefined
// Output: undefined: Your form is submitted for train number: undefined
// Output: undefined: This form is cancelled for train number: undefined

Now create constructor,

class Form {

    constructor() {
        this.name = "Gaurav"
        this.trainno = 0
    }

    submit() {
        console.log(this.name + ": Your form is submitted for train number: " + this.trainno)
    }

    cancel() {
        console.log(this.name + ": This form is cancelled for train number: " + this.trainno)
        this.trainno = 0
    }
    fill(givenname, trainno) {
        this.name = givenname
        this.trainno = trainno
    }

}

let myForm1 = new Form()

let myForm2 = new Form()

// myForm1.fill("Gaurav", 1234)
//
// myForm2.fill("Rahul", 5678)

myForm1.submit()

myForm2.submit()

myForm2.cancel()

// Output: Gaurav: Your form is submitted for train number: 0
// Output: Gaurav: Your form is submitted for train number: 0
// Output: Gaurav: This form is cancelled for train number: 0

⭐ Types of Constructors

Non-Parameterized Constructor: A constructor that has no arguments.

    class Example {
        constructor() {
            this.property = "default value";
        }
    }

Parameterized Constructor: A constructor that takes parameters.

    class Example {
        constructor(value) {
            this.property = value;
        }
    }

Copy Constructor: JavaScript does not have a built-in copy constructor like C++ or Java. However, you can create a method to copy an object.

    class Example {
        constructor(value) {
            this.property = value;
        }

        copy() {
            return new Example(this.property);
        }
    }

    const original = new Example("original value");
    const copy = original.copy();

Unlike languages like C++, JavaScript does not have destructors. Instead, JavaScript relies on an efficient garbage collector that automatically deallocates memory.

▶️ Inheritance

The capability of a class to derive properties and characteristics from another class is called Inheritance.

⭐ Why ?

If you don't know what is Inheritance

class Animal {
    constructor(name, color , age) {
        this.name = name
        this.color = color
        this.age = age
    }
    run() {
        console.log(this.name + ' is running')
    }

    shout() {

        console.log(this.name + ' is shouting')
    }

    sleep() {
        console.log(this.name + ' is sleeping')
    }
}

//If you are nub developer you will do
class Monkey {
    constructor(name, color) {
        this.name = name
        this.color = color
    }
    run() {
        console.log(this.name + ' is running')
    }

    shout() {

        console.log(this.name + ' is shouting')
    }

    sleep() {
        console.log(this.name + ' is sleeping')
    }

    eatBanana() {
        console.log(this.name + ' is eating banana')
    }
}

const animal_1 = new Monkey('Simba monkey', 'Brown', 2)

const animal_2 = new Animal('Donkey', 'White', 3)

animal_1.eatBanana()

animal_2.shout()

If you know

//Parent Class - Base Class
class Animal {
    constructor(name, color , age) {
        this.name = name
        this.color = color
        this.age = age
    }
    run() {
        console.log(this.name + ' is running')
    }

    shout() {

        console.log(this.name + ' is shouting')
    }

    sleep() {
        console.log(this.name + ' is sleeping')
    }
}

//Child Class - Derived Class
class Monkey extends Animal{
    eatBanana() {
        console.log(this.name + ' is eating banana')
    }
    //you can also add new methods
    hide() {
        console.log(this.name + ' is hiding')
    }
}

const animal_1 = new Monkey('Simba monkey', 'Brown', 2)

const animal_2 = new Animal('Donkey', 'White', 3)

animal_1.eatBanana()
animal_1.run()
animal_1.hide()

animal_2.shout()

⭐ Types of Inheritance

Single Inheritance when one class inherits another class, it is known as single level inheritance.

class Shape {
  area() {
    console.log("Displays Area of Shape");
  }
}

class Triangle extends Shape {
  area(h, b) {
    console.log((1/2) * b * h);
  }
}

const triangle = new Triangle();
triangle.area(10, 5); // Output: 25

Hierarchical Inheritance is defined as the process of deriving more than one class from a base class.

class Shape {
  area() {
    console.log("Displays Area of Shape");
  }
}

class Triangle extends Shape {
  area(h, b) {
    console.log((1/2) * b * h);
  }
}

class Circle extends Shape {
  area(r) {
    console.log(3.14 * r * r);
  }
}

const triangle = new Triangle();
triangle.area(10, 5); // Output: 25

const circle = new Circle();
circle.area(7); // Output: 153.86

Multilevel Inheritance is a process of deriving a class from another derived class.

class Shape {
  area() {
    console.log("Displays Area of Shape");
  }
}

class Triangle extends Shape {
  area(h, b) {
    console.log((1/2) * b * h);
  }
}

class EquilateralTriangle extends Triangle {
  constructor(side) {
    super();
    this.side = side;
  }

  area() {
    console.log((Math.sqrt(3) / 4) * this.side * this.side);
  }
}

const equilateralTriangle = new EquilateralTriangle(5);
equilateralTriangle.area(); // Output: 10.825317547305486

Hybrid Inheritance is a combination of simple, multiple inheritance and hierarchical inheritance. JavaScript does not support multiple inheritance directly, but we can achieve similar behavior using mixins.

class Shape {
  area() {
    console.log("Displays Area of Shape");
  }
}

class Triangle extends Shape {
  area(h, b) {
    console.log((1/2) * b * h);
  }
}

class Circle extends Shape {
  area(r) {
    console.log(3.14 * r * r);
  }
}

const mixin = (Base) => class extends Base {
  perimeter() {
    console.log("Calculates Perimeter");
  }
};

class EquilateralTriangle extends mixin(Triangle) {
  constructor(side) {
    super();
    this.side = side;
  }

  area() {
    console.log((Math.sqrt(3) / 4) * this.side * this.side);
  }
}

const equilateralTriangle = new EquilateralTriangle(5);
equilateralTriangle.area(); // Output: 10.825317547305486
equilateralTriangle.perimeter(); // Output: Calculates Perimeter

▶️ Method Overriding

If the same method is defined in both the superclass and the subclass, then the method of the subclass class overrides the method of the superclass

General

class human {
    constructor(name , age , body_type) {
        this.name = name
        this.age = age
        this.body_type = body_type
    }

    getName() {
        console.log("The name of the human is : ", this.name)
    }

    getAge() {

        console.log("The age of the human is :", this.age)
    }

    getBodyType() {
        console.log("The body type of the human is :", this.body_type)
    }
}

class student extends human {}

const student_1 = new student("Subham" , 24 , "Thin")

student_1.getAge() //The age of the human is : 24

⭐ Super Keyword - Types

The super keyword is used to call the parent class's constructor to access its properties and methods.

Overriding the Constructor

class Human {
    constructor(name, age, bodyType) {
        this.name = name;
        this.age = age;
        this.bodyType = bodyType;
    }

    getName() {
        console.log("The name of the human is:", this.name);
    }

    getAge() {
        console.log("The age of the human is:", this.age);
    }

    getBodyType() {
        console.log("The body type of the human is:", this.bodyType);
    }
}

class Student extends Human {
    constructor() {
        super("Rahul", 80, "Fat");
    }
}

const student1 = new Student();

student1.getName(); // The name of the human is: Rahul

Overriding a Method

class Human {
    constructor(name, age, bodyType) {
        this.name = name;
        this.age = age;
        this.bodyType = bodyType;
    }

    getName() {
        console.log("The name of the human is:", this.name);
    }

    getAge() {
        console.log("The age of the human is:", this.age);
    }

    getBodyType() {
        console.log("The body type of the human is:", this.bodyType);
    }
}

class Student extends Human {
    constructor() {
        super("Rahul", 80, "Fat");
    }

    // Overriding using super keyword in child class
    getAge() {
        super.getAge();
        console.log("The age of the student is:", 20);
    }
}

const student1 = new Student();

student1.getAge(); // The age of the human is: 80
                   // The age of the student is: 20

⭐ Key Points of Method Overriding

Same Method Name: The method in the child class must have the same name as in the parent class.
Same Parameters: The method in the child class must have the same parameter list as the parent class method.
IS-A Relationship: Method overriding only occurs in two classes that have an IS-A relationship (inheritance).
Access Modifiers: The overriding method can have a less restrictive access modifier, but not a more restrictive one.
Super Keyword: You can use the super keyword to call the overridden method from the parent class.

⭐ Extra Notes

Note 1

class human {
    constructor() {
        console.log("Human class constructor")
    }
    eat() {
        console.log("Human can eat")
    }
}
class student extends human {
}
const student_1 = new student()
student_1.eat()

//Human class constructor
// Human can eat

If you don’t explicitly define a constructor in a subclass, JavaScript will automatically create one for you that calls the parent class’s constructor using super().
like this

class human {
    constructor() {
        console.log("Human class constructor")
    }
    eat() {
        console.log("Human can eat")
    }
}
class student extends human {
    constructor(...arg) {
        super(...arg);
    }
}
const student_1 = new student()
student_1.eat()

Note 2

class human {
    constructor() {
        console.log("Human class constructor")
    }
    eat() {
        console.log("Human can eat")
    }
}
class student extends human {
    constructor() {
        console.log("This is student class constructor")
    }
}
const student_1 = new student()
student_1.eat()

// console.log("This is student class constructor")
//ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor

You have to use super keyword like this

class human {
    constructor() {
        console.log("Human class constructor")
    }
    eat() {
        console.log("Human can eat")
    }
}
class student extends human {
    constructor() {
        super()
        console.log("This is student class constructor")
    }
}
const student_1 = new student()
student_1.eat()

Note 3

class human {
    constructor(name) {
        console.log("Human class constructor" , name)
        this.name = name
    }
    eat() {
        console.log("Human can eat")
    }
}
class student extends human {
    constructor(name) {
        this.name = name //not allow
        super()
        console.log("Student class constructor" , name)

    }
}
const student_1 = new student("subham")
student_1.eat()

// this.name = name
// ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor

After super keyword you can use this

class human {
    constructor(name) {
        console.log("Human class constructor" , name)
        this.name = name
    }
    eat() {
        console.log("Human can eat")
    }
}
class student extends human {
    constructor(name) {
        super()
        this.name = name
        console.log("Student class constructor" , name)

    }
}
const student_1 = new student("subham")
student_1.eat()

// Human class constructor undefined
// Student class constructor subham
// Human can eat

▶️ Method Overloading

Having two or more methods (or functions) in a class with the same name and different arguments (or parameters)

⭐ Can We Overload a Function in JavaScript?

In JavaScript, method overloading as seen in some other languages (like Java) is not natively supported. This means you cannot define multiple methods with the same name but different parameters in the same class. However, you can achieve similar functionality using techniques like checking the number and type of arguments within a single method.

You can't do this in JS

class Calculator {
    add(a, b) {
        return a + b;
    }

    add(a, b, c) {
        return a + b + c;
    }
}

const calc = new Calculator();
console.log(calc.add(1, 2)); // This will throw an error because the first add method is overwritten

If you want, you can achieve by doing this

class Calculator {
    add(...args) {
        if (args.length === 2) {
            return args[0] + args[1];
        } else if (args.length === 3) {
            return args[0] + args[1] + args[2];
        } else {
            throw new Error("Invalid number of arguments");
        }
    }
}

const calc = new Calculator();

console.log(calc.add(1, 2)); // Output: 3
console.log(calc.add(1, 2, 3)); // Output: 6

▶️ Access Modifiers

Access modifier is a keyword that is used to set the accessibility of a class member

⭐ Types of Access Modifiers

Public: Members declared as public are accessible from any other class.
Protected: Members declared as protected are accessible within the same class and by derived class instances.
Private: Members declared as private are accessible only within the same class.

⭐ Accessibility Table

Modifier	Parent Class	Child Class	Outside Class
Public	✔️	✔️	✔️
Protected	✔️	✔️	❌
Private	✔️	❌	❌

⭐ Example

1. Public Members

Public members are accessible from anywhere.

class Parent {
    publicProperty = "I'm public";

    publicMethod() {
        return "This is a public method";
    }
}

class Child extends Parent {
    useParentPublic() {
        console.log(this.publicProperty);
        console.log(this.publicMethod());
    }
}

const parent = new Parent();
const child = new Child();

console.log(parent.publicProperty);  // Output: I'm public
console.log(parent.publicMethod());  // Output: This is a public method
child.useParentPublic();
// Output: 
// I'm public
// This is a public method

In this example, publicProperty and publicMethod are accessible from:

Within the Parent class
Within the Child class
Outside any class

2. Protected Members (Simulated)

In JavaScript, we use an underscore prefix to indicate protected members by convention. They're still technically public, but developers agree not to access them directly outside the class or its subclasses.

class Parent {
    _protectedProperty = "I'm protected";

    _protectedMethod() {
        return "This is a protected method";
    }
}

class Child extends Parent {
    useParentProtected() {
        console.log(this._protectedProperty);
        console.log(this._protectedMethod());
    }
}

const parent = new Parent();
const child = new Child();

child.useParentProtected();
// Output:
// I'm protected
// This is a protected method

// These work, but violate the convention:
console.log(parent._protectedProperty);
console.log(parent._protectedMethod());

In this scenario:

_protectedProperty and _protectedMethod are accessible within Parent
They're also accessible within Child (inheritance)
They're technically accessible outside, but this violates the convention

3. Private Members

Private members are truly private and only accessible within the class they're defined in.

class Parent {
    #privateProperty = "I'm private";

    #privateMethod() {
        return "This is a private method";
    }

    usePrivate() {
        console.log(this.#privateProperty);
        console.log(this.#privateMethod());
    }
}

class Child extends Parent {
    tryToUseParentPrivate() {
        // These would cause errors if uncommented:
        // console.log(this.#privateProperty);
        // console.log(this.#privateMethod());
    }
}

const parent = new Parent();
const child = new Child();

parent.usePrivate();
// Output:
// I'm private
// This is a private method

// These would cause errors:
// console.log(parent.#privateProperty);
// console.log(parent.#privateMethod());
// child.tryToUseParentPrivate();

In this case:

#privateProperty and #privateMethod are only accessible within Parent
They're not accessible in Child, even though it extends Parent
They're not accessible outside the class at all

Key Takeaways

Public members (default) are accessible everywhere.
Protected members (convention with _) are accessible within the class and subclasses, but shouldn't be accessed outside (though technically they can be).
Private members (with #) are only accessible within the defining class, not in subclasses or outside.
When using protected members, they behave like public members in terms of accessibility, but developers agree to treat them as if they were protected.
True privacy and encapsulation are only achieved with private members using the # syntax.

▶️ Static

The static keyword defines a static method or field for a class

A static method is a method that belongs to the class itself, not to any specific instance of the class.

class Animal {
    constructor(name) {
        this.name = Animal.capitalize(name);
    }

    static capitalize(name) {
        return name.charAt(0).toUpperCase() + name.slice(1);
    }

    walk() {
        console.log(`Animal ${this.name} is walking`);
    }
}

const animal = new Animal("lion");
animal.walk(); // Output: Animal Lion is walking

console.log(Animal.capitalize("elephant")); // Output: Elephant

Key points:

The capitalize method is declared as static using the static keyword.
It's called on the class (Animal.capitalize) not on instances.
It can be used inside the constructor or other methods using the class name.

⭐ Inheritance and Static Methods

Static methods are inherited by subclasses:

class Human extends Animal {
    static greet() {
        console.log("Hello!");
    }
}

const human = new Human("john");
human.walk(); // Output: Animal John is walking

console.log(Human.capitalize("sarah")); // Output: Sarah
Human.greet(); // Output: Hello!

Note:

The Human class inherits the static capitalize method from Animal.
Human can also define its own static methods, like greet.

⭐ Calling Static Methods from Non-Static Methods

You can call static methods from non-static methods, but you need to use the class name:

class Calculator {
    static add(a, b) {
        return a + b;
    }

    multiply(a, b) {
        // Using a static method in a non-static method
        return Calculator.add(a, 0) * b;
    }
}

const calc = new Calculator();
console.log(calc.multiply(3, 4)); // Output: 12
console.log(Calculator.add(5, 6)); // Output: 11

⭐ Static Methods vs. Instance Methods

Here's a comparison to illustrate the difference:

class MyClass {
    static staticMethod() {
        return "I'm a static method";
    }

    instanceMethod() {
        return "I'm an instance method";
    }
}

console.log(MyClass.staticMethod()); // Output: I'm a static method

const obj = new MyClass();
console.log(obj.instanceMethod()); // Output: I'm an instance method

// This would throw an error:
// console.log(MyClass.instanceMethod());

// This would also throw an error:
// console.log(obj.staticMethod());

⭐ Use Cases for Static Methods

Utility Functions: Methods that don't require object state.
Factory Methods: Creating instances with special properties.
Cache or Fixed-Configuration: Storing shared data for all instances.

Example of a factory method:

class User {
    constructor(name, role) {
        this.name = name;
        this.role = role;
    }

    static createAdmin(name) {
        return new User(name, "admin");
    }
}

const admin = User.createAdmin("Alice");
console.log(admin.role); // Output: admin

⭐ Key Takeaways

Static methods are defined on the class, not instances.
They're called using the class name: ClassName.methodName().
They can be inherited by subclasses.
They can't directly access instance properties or methods.
They're useful for utility functions, factory methods, and managing class-level data.
You can't call static methods on instances, and you can't call instance methods on the class.

▶️ Getter & Setter

Getters and setters are functions that allow you to get and set object values, respectively

//getter setter
class human {
    constructor(name, age) {
        this._name = name;
    }
    get getName() {
        return this._name;
    }
    set setName(name) {
        this._name = name;
    }
}

const person = new human("", 0);
person.setName = "Raj";
person.setAge = 25;

console.log(person.getName);
console.log(person.getAge);

//Raj
//25

▶️ instanceOf Operator

Check if an object is an instance of a class, subclass, or interface

//getter setter
class human {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    get getName() {
        return this.name;
    }
    set setName(name) {
        this.name = name;
    }
    get getAge() {
        return this.age;
    }
    set setAge(age) {
        this.age = age;
    }
}

const person = new human("", 0);
person.setName = "Raj";
person.setAge = 25;

console.log(person.getName);
console.log(person.getAge);

const person1 = "Subham"

console.log( person instanceof human)//true
console.log( person1 instanceof human)//false

It also returns true for subclass

//getter setter
class human {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    get getName() {
        return this.name;
    }
    set setName(name) {
        this.name = name;
    }
    get getAge() {
        return this.age;
    }
    set setAge(age) {
        this.age = age;
    }
}

class Coder extends human {
    constructor(name, age, language) {
        super(name, age);
        this.language = language;
    }
}

const person = new human("", 0);
const subham = new Coder("subham", 22, "java");
person.setName = "Raj";
person.setAge = 25;


console.log( person instanceof human)
console.log( subham instanceof human)

▶️ Encapsulation

Encapsulation is a way to restrict the direct access to some components of an object

class BankAccount {
    #balance; // Private field

    constructor(initialBalance) {
        this.#balance = initialBalance;
    }

    deposit(amount) {
        if (amount > 0) {
            this.#balance += amount;
        }
    }

    getBalance() {
        return this.#balance;
    }
}

const account = new BankAccount(1000);
account.deposit(500);
console.log(account.getBalance()); // 1500
// console.log(account.#balance); // Syntax error: private field

//Encapsulation
const user = {
    firstName: "John",
    lastName: "Doe",
    age: 25,
    getAgeYear: function() {
        return new Date().getFullYear() - this.age;
    }
}
console.log(user.getAgeYear());

▶️ Polymorphism

Polymorphism means "many forms", and it occurs when we have many classes that are related to each other by inheritance.

// Parent class
class Animal {
  makeSound() {
    console.log("The animal makes a sound");
  }
}

// Child classes
class Dog extends Animal {
  makeSound() {
    console.log("The dog barks");
  }
}

class Cat extends Animal {
  makeSound() {
    console.log("The cat meows");
  }
}

// Function to demonstrate polymorphism
function animalSound(animal) {
  animal.makeSound();
}

// Usage
const animal = new Animal();
const dog = new Dog();
const cat = new Cat();

animalSound(animal); // Output: The animal makes a sound
animalSound(dog); // Output: The dog barks
animalSound(cat); // Output: The cat meows

▶️ Abstraction

Abstraction is the concept of hiding complex implementation details and showing only the necessary features of an object.

// Abstraction: Hiding complex implementation details and showing only the necessary features of an object.

// Abstract class
class Vehicle {
    constructor(brand) {
        this.brand = brand;
    }

    // Abstract method
    start() {
        throw new Error("Method 'start()' must be implemented.");
    }

    getBrand() {
        return this.brand;
    }
}

// Concrete class
class Car extends Vehicle {
    start() {
        return `${this.brand} car is starting...`;
    }
}

// Usage
const myCar = new Car("Toyota");
console.log(myCar.getBrand()); // Output: Toyota
console.log(myCar.start());    // Output: Toyota car is starting...

Kth Largest Element in an Array

Subham — Mon, 23 Sep 2024 14:38:36 +0000

#️⃣ Array, Priority Queue, Quick Select

https://leetcode.com/problems/kth-largest-element-in-an-array/description

🔥 Understand Problem

If the array is [8, 6, 12, 9, 3, 4] and k is 2, you need to find the 2nd largest element in this array. First, you will sort the array: [3, 4, 6, 8, 9, 12] The output will be 9 because it is the second-largest element.

✅ Bruteforce

var findKthLargest = function(nums, k) {
    // Sort the array in ascending order
    nums.sort((a, b) => a - b);

    // Return the kth largest element
    return nums[nums.length - k];
};

Explanation:

Sorting the Array: The array is sorted in ascending order using the sort method.
Finding the kth Largest Element: The kth largest element is found by accessing the element at the index nums.length - k.

Time Complexity:

Sorting: The time complexity of sorting an array is (O(nlog n)), where (n) is the length of the array.
Accessing the Element: Accessing an element in an array is O(1).

So, the overall time complexity is O(n log n).

Space Complexity:

In-Place Sorting: The sort method sorts the array in place, so the space complexity is O(1) for the sorting operation.
Overall: Since we are not using any additional data structures, the overall space complexity is O(1).

✅ Better

var findKthLargest = function(nums, k) {
        // Create a min-heap using a priority queue
        let minHeap = new MinPriorityQueue();

        // Add the first k elements to the heap
        for (let i = 0; i < k; i++) {
            //minHeap.enqueue(nums[i]): Adds the element nums[i] to the min-heap.
            minHeap.enqueue(nums[i]);
        }

        // Iterate through the remaining elements
        for (let i = k; i < nums.length; i++) {
            //minHeap.front().element: Retrieves the smallest element in the min-heap without removing it.
            if (minHeap.front().element < nums[i]) {
                // minHeap.dequeue(): Removes the smallest element from the min-heap.
                minHeap.dequeue();
                // Add the current element
                minHeap.enqueue(nums[i]);
            }
        }

        // The root of the heap is the kth largest element
        return minHeap.front().element;
    };

Explanation:

Initial Array: [2, 1, 6, 3, 5, 4]
k = 3: We need to find the 3rd largest element.

Step 1: Add the first k elements to the min-heap

Heap after adding 2: [2]
Heap after adding 1: [1, 2]
Heap after adding 6: [1, 2, 6]

Step 2: Iterate through the remaining elements

Current element = 3
- Heap before comparison: [1, 2, 6]
- Smallest element in heap (minHeap.front().element): 1
- Comparison: 3 > 1
- Action: Remove 1 and add 3
- Heap after update: [2, 6, 3]
Current element = 5
- Heap before comparison: [2, 6, 3]
- Smallest element in heap (minHeap.front().element): 2
- Comparison: 5 > 2
- Action: Remove 2 and add 5
- Heap after update: [3, 6, 5]
Current element = 4
- Heap before comparison: [3, 6, 5]
- Smallest element in heap (minHeap.front().element): 3
- Comparison: 4 > 3
- Action: Remove 3 and add 4
- Heap after update: [4, 6, 5]

Final Step: Return the root of the heap

Heap: [4, 6, 5]
3rd largest element: 4 (the root of the heap)

Time Complexity:

Heap Operations: Inserting and removing elements from the heap takes O(log k) time.
Overall: Since we perform these operations for each of the n elements in the array, the overall time complexity is O(n log k).

Space Complexity:

Heap Storage: The space complexity is O(k) because the heap stores at most k elements.

✅ Best

Note: Even though Leetcode restricts quick select, you should remember this approach because it passes most test cases

//Quick Select Algo

function quickSelect(list, left, right, k)

   if left = right
      return list[left]

   Select a pivotIndex between left and right

   pivotIndex := partition(list, left, right, 
                                  pivotIndex)
   if k = pivotIndex
      return list[k]
   else if k < pivotIndex
      right := pivotIndex - 1
   else
      left := pivotIndex + 1

var findKthLargest = function(nums, k) {
    // Call the quickSelect function to find the kth largest element
    return quickSelect(nums, 0, nums.length - 1, nums.length - k);
};

function quickSelect(nums, low, high, index) {
    // If the low and high pointers are the same, return the element at low
    if (low === high) return nums[low];

    // Partition the array and get the pivot index
    let pivotIndex = partition(nums, low, high);

    // If the pivot index is the target index, return the element at pivot index
    if (pivotIndex === index) {
        return nums[pivotIndex];
    } else if (pivotIndex > index) {
        // If the pivot index is greater than the target index, search in the left partition
        return quickSelect(nums, low, pivotIndex - 1, index);
    } else {
        // If the pivot index is less than the target index, search in the right partition
        return quickSelect(nums, pivotIndex + 1, high, index);
    }
}

function partition(nums, low, high) {
    // Choose the pivot element
    let pivot = nums[high];
    let pointer = low;

    // Rearrange the elements based on the pivot
    for (let i = low; i < high; i++) {
        if (nums[i] <= pivot) {
            [nums[i], nums[pointer]] = [nums[pointer], nums[i]];
            pointer++;
        }
    }

    // Place the pivot element in its correct position
    [nums[pointer], nums[high]] = [nums[high], nums[pointer]];
    return pointer;
}

Explanation:

Initial Array: [3, 2, 1, 5, 6, 4]
k = 2: We need to find the 2nd largest element.

Step 1: Partition the array

Pivot element = 4
Array after partitioning: [3, 2, 1, 4, 6, 5]
Pivot index = 3

Step 2: Recursive Selection

Target index = 4 (since we need the 2nd largest element, which is the 4th index in 0-based indexing)
Pivot index (3) < Target index (4): Search in the right partition [6, 5]

Step 3: Partition the right partition

Pivot element = 5
Array after partitioning: [3, 2, 1, 4, 5, 6]
Pivot index = 4

Final Step: Return the element at the target index

Element at index 4: 5

Time Complexity:

Average Case: The average time complexity of Quickselect is O(n).
Worst Case: The worst-case time complexity is O(n^2), but this is rare with good pivot selection.

Space Complexity:

In-Place: The space complexity is O(1) because the algorithm works in place.