<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[NextHire]]></title><description><![CDATA[NextHire]]></description><link>https://nexthire-by-sloktulsyan.hashnode.dev</link><generator>RSS for Node</generator><lastBuildDate>Sun, 22 Nov 2026 16:41:06 GMT</lastBuildDate><atom:link href="https://nexthire-by-sloktulsyan.hashnode.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[The Day I Thought Deployment Was Done: NextHire]]></title><description><![CDATA[This blog is in contiuation of my previous post where I built and deployed “NextHire”, a microservice-based job portal using Node.js, Kafka, Redis, Docker…]]></description><link>https://nexthire-by-sloktulsyan.hashnode.dev/the-day-i-thought-deployment-was-done-nexthire</link><guid isPermaLink="true">https://nexthire-by-sloktulsyan.hashnode.dev/the-day-i-thought-deployment-was-done-nexthire</guid><category><![CDATA[nginx]]></category><category><![CDATA[deployment]]></category><category><![CDATA[proxy]]></category><category><![CDATA[Reverse Proxy]]></category><category><![CDATA[kafka]]></category><category><![CDATA[Docker]]></category><dc:creator><![CDATA[Slok Tulsyan]]></dc:creator><pubDate>Mon, 22 Dec 2025 14:44:00 GMT</pubDate><enclosure url="https://cdn.hashnode.com/res/hashnode/image/upload/v1766391851342/0c99a69a-6414-40b8-832c-c104d2343c28.png" length="0" type="image/jpeg"/><content:encoded><![CDATA[<blockquote>
<p>This blog is in contiuation of my previous post where I built and deployed “NextHire”, a microservice-based job portal using Node.js, Kafka, Redis, Docker and Next.js. <a target="_blank" href="https://nexthire-by-sloktulsyan.hashnode.dev/from-comfort-to-chaos-building-and-deploying-nexthire-taught-me-more-than-coding-ever-did">Read here</a></p>
</blockquote>
<p>When everything finally started working, I genuinely felt relief.</p>
<ul>
<li><p>All services were up.</p>
</li>
<li><p>Kafka was running.</p>
</li>
<li><p>Emails were being sent.</p>
</li>
<li><p>Frontend was live.</p>
</li>
<li><p>APIs were responding.</p>
</li>
</ul>
<p>For the first time in weeks, I was not staring at the Docker logs. And that’s when I made a mistake. I thought:</p>
<blockquote>
<p><strong>“Let’s make it more production-ready.”</strong></p>
</blockquote>
<p>That thought led me straight to <strong>Nginx</strong>.</p>
<hr />
<h2 id="heading-why-i-even-touched-nginx">Why I Even Touched Nginx</h2>
<p>Until this point, my system was looking like:</p>
<ul>
<li><p>Frontend → <code>http://&lt;IP&gt;:3000</code></p>
</li>
<li><p>Auth → <code>http://&lt;IP&gt;:5000</code></p>
</li>
<li><p>Utils → <code>http://&lt;IP&gt;:5001</code></p>
</li>
<li><p>User → <code>http://&lt;IP&gt;:5002</code></p>
</li>
<li><p>Job → <code>http://&lt;IP&gt;:5003</code></p>
</li>
</ul>
<p>It worked, but it felt… wrong. Ports everywhere. Hardcoded URLs in <code>.env</code>. Frontend is tightly coupled with the backend. So I decided:</p>
<blockquote>
<p>Let’s introduce a <strong>single entry point</strong>.</p>
</blockquote>
<ul>
<li><p>No ports exposed to users.</p>
</li>
<li><p>Clean URLs like <code>/api/job</code>, <code>/api/user</code></p>
</li>
<li><p>Proper reverse proxy</p>
</li>
<li><p>Something closer to <strong>real production setups</strong></p>
</li>
</ul>
<h3 id="heading-the-first-victory-nginx-is-running">The First Victory: Nginx Is Running</h3>
<p>I installed Nginx on my VM. Set up a basic config and restarted all the services.</p>
<p>And <strong>boom</strong>.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1766401939766/ae79f008-923d-472e-86d8-1fe8ef79672c.png" alt class="image--center mx-auto" /></p>
<p>It was running. That felt like progress. Then I tried hitting the backend through Nginx. And immediately:</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1766402019701/c2f0a4a8-87f2-4c62-9059-35ee2d411992.webp" alt class="image--center mx-auto" /></p>
<h3 id="heading-the-502-phase-confidence-confusion">The 502 Phase: Confidence → Confusion</h3>
<p>At this point, nothing made sense.</p>
<ul>
<li><p>The backend was running fine</p>
</li>
<li><p>Containers were healthy</p>
</li>
<li><p>Ports were accessible directly</p>
</li>
<li><p>Nginx was up</p>
</li>
</ul>
<p>Yet Nginx said:</p>
<blockquote>
<p>“Bad Gateway”</p>
</blockquote>
<p>I learned something important here:</p>
<blockquote>
<p><strong>502 doesn’t mean your backend is down. It means Nginx can’t reach it.</strong></p>
</blockquote>
<h3 id="heading-talking-to-containers-like-theyre-on-the-host">Talking to Containers Like They’re On The Host</h3>
<p>Initially, my nginx config tried to proxy to:</p>
<pre><code class="lang-nginx"><span class="hljs-attribute">proxy_pass</span> http://localhost:5003;
</code></pre>
<p>But my services were running inside the <strong>Docker containers</strong>, not directly on the host.</p>
<p>That’s when it hit me:</p>
<blockquote>
<p>Nginx doesn’t care that Docker exists.</p>
</blockquote>
<p>To Nginx:</p>
<ul>
<li><p>Either something is reachable</p>
</li>
<li><p>Or it isn’t</p>
</li>
</ul>
<p>So I had to rethink how traffic flows.</p>
<h3 id="heading-docker-nginx-two-worlds-one-bridge">Docker + Nginx: Two Worlds, One Bridge</h3>
<p>There were two ways forward:</p>
<ul>
<li><p>Proxy to <strong>host-mapped ports</strong></p>
</li>
<li><p>Proxy directly to <strong>Docker services via the network</strong></p>
</li>
</ul>
<p>Since my services were already exposed, I chose the simpler route:</p>
<pre><code class="lang-nginx"><span class="hljs-attribute">location</span> /api/job/ {
    <span class="hljs-attribute">proxy_pass</span> http://127.0.0.1:5003/;
}
</code></pre>
<p>Restarted nginx.</p>
<blockquote>
<p><strong>“Frontend loaded.”</strong></p>
</blockquote>
<h3 id="heading-new-problem-frontend-works-data-doesnt">New Problem: Frontend Works, Data Doesn’t</h3>
<p>The UI was visible now. But API calls failed. Network tab showed:</p>
<pre><code class="lang-bash">GET /api/job/company → 404
</code></pre>
<p>This was the moment I understood:</p>
<blockquote>
<p>Nginx Routing ≠ Backend Routing</p>
</blockquote>
<p>If Nginx doesn’t forward the path correctly, your backend never sees the route you think it does.</p>
<p><strong>“A missing slash. A mismatched path. A wrong rewrite.”</strong></p>
<p>Any one of them breaks everything. Fixing this taught me:</p>
<ul>
<li><p>how <code>proxy_pass</code> actually works</p>
</li>
<li><p>how trailing slashes change behaviour</p>
</li>
<li><p>why <code>/api/job</code> ≠ <code>/api/job/</code></p>
</li>
</ul>
<h3 id="heading-the-hidden-enemy-environment-variables">The Hidden Enemy: Environment Variables</h3>
<p>Just when things started working again, another issue surfaced. Some APIs worked. Some didn’t. Why?</p>
<p>Because my services still had values like:</p>
<pre><code class="lang-bash">KAFKA_BROKER=20.187.78.13:9092
FRONTEND_URL=http://20.187.78.13:3000
FILE_UPLOAD_SERVICE_URL=http://20.187.78.13:5001
</code></pre>
<p>These were <strong>deployment-time hacks</strong>, not production design.</p>
<p>With Nginx in the picture:</p>
<ul>
<li><p>services should talk to <strong>service names</strong></p>
</li>
<li><p>frontend should talk to <strong>IP</strong></p>
</li>
<li><p>no IP + port chaos</p>
</li>
</ul>
<p>So I refactored:</p>
<ul>
<li><p>frontend → uses IP</p>
</li>
<li><p>backend → uses internal Docker service names</p>
</li>
<li><p>kafka → uses <code>kafka:9092</code></p>
</li>
</ul>
<p>This single change eliminated half the instability.</p>
<h3 id="heading-kafka-broke-again-of-course-it-did">Kafka Broke Again (Of Course It Did)</h3>
<p>One last punch from reality. Mail service stopped working. Logs showed:</p>
<pre><code class="lang-nginx"><span class="hljs-attribute">ECONNREFUSED</span> kafka:<span class="hljs-number">9092</span>
</code></pre>
<p>Kafka was running. But Kafka was not <strong>advertising itself correctly</strong>.</p>
<p>The classic Kafka problem it was.</p>
<p>The fix?</p>
<ul>
<li><p>Proper <code>KAFKA_ADVERTISED_LISTENERS</code></p>
</li>
<li><p>Correct internal Docker hostname</p>
</li>
<li><p>No public IP leakage inside containers</p>
</li>
</ul>
<p>After fixing this… Emails started sending again.</p>
<hr />
<h2 id="heading-what-nginx-actually-taught-me">What Nginx Actually Taught Me</h2>
<p>Nginx didn’t just give me clean URLs. It taught me:</p>
<ul>
<li><p>how real traffic flows</p>
</li>
<li><p>why reverse proxies matter</p>
</li>
<li><p>how Docker networking works in production</p>
</li>
<li><p>why env design is as important as code</p>
</li>
<li><p>why “it works on my machine“ is meaningless</p>
</li>
</ul>
<p>Most importantly:</p>
<blockquote>
<p>Deployment is not a final step. <strong>It’s a new phase of engineering</strong>.</p>
</blockquote>
<h2 id="heading-conclusion">Conclusion</h2>
<p>If you’re reading this and thinking:</p>
<blockquote>
<p>“This feels too complex for a personal project.”</p>
</blockquote>
<p>That’s exactly why it was worth doing.</p>
<p>I didn’t learn Nginx by reading docs. I learned it because my system broke — repeatedly.</p>
<p>And now?</p>
<p>Next time I deploy something, I won’t fear production.</p>
<blockquote>
<p><strong><em>💬 If you have any doubts, feel free to comment below or ask your queries — I’ll be happy to help!</em></strong></p>
</blockquote>
]]></content:encoded></item><item><title><![CDATA[From Comfort to Chaos: Building & Deploying NextHire Taught Me More Than Coding Ever Did]]></title><description><![CDATA[NextHire - Your one-step solution for job hunting and recruitment]]></description><link>https://nexthire-by-sloktulsyan.hashnode.dev/from-comfort-to-chaos-building-and-deploying-nexthire-taught-me-more-than-coding-ever-did</link><guid isPermaLink="true">https://nexthire-by-sloktulsyan.hashnode.dev/from-comfort-to-chaos-building-and-deploying-nexthire-taught-me-more-than-coding-ever-did</guid><category><![CDATA[kafka]]></category><category><![CDATA[Microservices]]></category><category><![CDATA[Docker]]></category><category><![CDATA[Redis]]></category><category><![CDATA[PostgreSQL]]></category><category><![CDATA[NeonDB ]]></category><category><![CDATA[Node.js]]></category><category><![CDATA[Express]]></category><category><![CDATA[Next.js]]></category><category><![CDATA[cloudinary]]></category><category><![CDATA[multer]]></category><category><![CDATA[shadcn ui]]></category><category><![CDATA[Job Hunting]]></category><category><![CDATA[recruitment]]></category><category><![CDATA[deployment]]></category><dc:creator><![CDATA[Slok Tulsyan]]></dc:creator><pubDate>Mon, 22 Dec 2025 08:14:22 GMT</pubDate><enclosure url="https://cdn.hashnode.com/res/hashnode/image/upload/v1766318147080/4d88aa7d-81a3-437f-a4d8-33c11b65ad35.png" length="0" type="image/jpeg"/><content:encoded><![CDATA[<p>For a long time, I didn’t build any personal project. Not because I didn’t want to — but because life happened. My time was consumed by <strong>summer internship preparation,</strong> then <strong>academics,</strong> then <strong>examinations,</strong> and after all that… I did what most of us all do — I chilled. I told myself, <em>“I deserve this break.”</em> And honestly, I did.</p>
<p>But after a point, comfort starts feeling dangerous as well as boring. I had an internship, and things were stable, but somewhere deep inside I knew — <em>if I don’t start building again, I’ll slowly stop growing.</em> So, I decided to get back.</p>
<h2 id="heading-looking-for-a-different-project">Looking for a “different” project</h2>
<p>This time, I didn’t want to build just <strong>another CRUD app</strong>.</p>
<p>I wasn’t chasing a flashy idea. I was chasing <strong>learning</strong>, especially <strong>system design</strong>.</p>
<p>So instead of asking:</p>
<blockquote>
<p>“What problem should I solve?”</p>
</blockquote>
<p>I asked:</p>
<blockquote>
<p>“What technologies scare me a little?“</p>
</blockquote>
<p>That question changed everything. After some searching and thinking, I decided to build a <strong>job portal</strong> — something like a simplified hiring platform — and name it <strong>NextHire</strong>. On the surface, the idea was not revolutionary, but the <strong>tech stack</strong> absolutely was — at least for me.</p>
<h2 id="heading-what-i-decided-to-use-and-why-it-was-scary">What I decided to use and why it was scary</h2>
<p>I intentionally picked tools that were <strong>new or uncomfortable</strong> for me:</p>
<ul>
<li><p><strong>Microservices architecture</strong> (instead of a single backend)</p>
</li>
<li><p><strong>Node.js + Express.js</strong> for backend services</p>
</li>
<li><p><strong>PostgreSQL(NeonDB)</strong> as the primary database</p>
</li>
<li><p><strong>Redis</strong> for caching and fast lookups</p>
</li>
<li><p><strong>Kafka(kafka.js)</strong> for background tasks like sending emails</p>
</li>
<li><p><strong>Cloudinary + Multer</strong> for image and PDF uploads (profile picture, resume)</p>
</li>
<li><p><strong>Next.js</strong> for frontend</p>
</li>
<li><p><strong>ShadCN/UI</strong> for clean UI components</p>
</li>
</ul>
<p>Among all of these:</p>
<ul>
<li><p>Kafka</p>
</li>
<li><p>Redis</p>
</li>
<li><p>Cloudinary</p>
</li>
<li><p>Next.js (in a serious project)</p>
</li>
<li><p>And later… <strong>Docker</strong></p>
</li>
</ul>
<p>were new territories for me. So while the <em>idea</em> of NextHire wasn’t very exciting, <strong>building it definitely was</strong>.</p>
<hr />
<h2 id="heading-building-nexthire-everything-worked-locally">Building NextHire: everything worked… locally</h2>
<p>NextHire follows a <strong>microservices architecture</strong> where each service owns a specific business responsibility. Services communicate using <strong>REST APIs</strong> and <strong>Apache Kafka</strong> for asynchronous event handling.</p>
<h3 id="heading-core-services">Core Services</h3>
<ol>
<li><p><strong>Authentication Service</strong></p>
<ul>
<li><p>Handles user signup, login, and JWT-based authentication</p>
</li>
<li><p>Uses <strong>bcrypt</strong> for password hashing</p>
</li>
<li><p>Issue role-based JWT tokens for authorisation</p>
</li>
<li><p>Publish events for email notifications (for email verification via OTP, for welcoming new users)</p>
</li>
</ul>
</li>
<li><p><strong>User Service</strong></p>
<ul>
<li><p>Manages user profiles, skills and subscriptions</p>
</li>
<li><p>Supports both job seekers and recruiters</p>
</li>
<li><p>Implement premium subscription logic (priority applications, enhanced visibility)</p>
</li>
</ul>
</li>
<li><p><strong>Job Service</strong></p>
<ul>
<li><p>Handles companies, job postings and applications</p>
</li>
<li><p>Supports advanced filtering (skills, location, role, job type, salary range)</p>
</li>
<li><p>Implements application status tracking and recruiter workflows</p>
</li>
<li><p>Publish events for email notifications (for application status update)</p>
</li>
</ul>
</li>
<li><p><strong>Utils Service</strong></p>
<ul>
<li><p>Handles file uploads using <strong>Cloudinary</strong></p>
</li>
<li><p>Performs resume analysis and generates career guidance using <strong>Google Generative AI</strong></p>
</li>
<li><p>Consumes Kafka events to send email notifications</p>
</li>
</ul>
</li>
</ol>
<p>Slowly, piece by piece, everything came together. And then came that satisfying moment:</p>
<blockquote>
<p><strong>“The whole is working.”</strong></p>
</blockquote>
<p>Locally.</p>
<p>The word — locally — would soon come back to haunt me.</p>
<hr />
<h2 id="heading-lets-deploy-it-famous-last-words">“Let’s deploy it” — famous last words</h2>
<p>After finishing development, I thought:</p>
<blockquote>
<p><em>“Okay, now I’ll deploy it. How hard can it be?”</em></p>
</blockquote>
<p>That was my biggest mistake.</p>
<p>I decided to <strong>Dockerise</strong> everything — because that’s what “real projects” do, right?</p>
<p>Docker was also new to me, but initially, it felt manageable:</p>
<ul>
<li><p>Write a Dockerfile</p>
</li>
<li><p>Build the image</p>
</li>
<li><p>Run the container</p>
</li>
</ul>
<p>So I Dockerised:</p>
<ul>
<li><p>All four backend services individually</p>
</li>
<li><p>Kafka</p>
</li>
<li><p>Client</p>
</li>
</ul>
<p>And then came the <strong>real struggle</strong>.</p>
<h3 id="heading-the-deployment-nightmare-nobody-warns-you-about">The deployment nightmare nobody warns you about</h3>
<p>Here’s what my workflow looked like initially:</p>
<ol>
<li><p>Make a small change in the code</p>
</li>
<li><p>Rebuild Docker image</p>
</li>
<li><p>Push image to Docker Hub</p>
</li>
<li><p>SSH into VM</p>
</li>
<li><p>Pull the image</p>
</li>
<li><p>Stop the old container</p>
</li>
<li><p>Run the new container</p>
</li>
<li><p>Repeat this for <strong>every service</strong> (auth, utils, user, job, client)</p>
</li>
</ol>
<p>A single typo could cost <strong>15-20 minutes.</strong> That wasn’t even the worst part.</p>
<h3 id="heading-kafka-refusing-connections">Kafka refusing connections</h3>
<p>Kafka kept throwing <code>ECONNREFUSED</code>. The broker was running. Ports were open. Logs looked fine. I even tried opening <strong>Kafka’s IP in a browser</strong>.</p>
<p>Nothing.</p>
<p>Later, I realised something fundamental.</p>
<blockquote>
<p><strong>Kafka is not HTTP. You don’t “open“ it in a browser.</strong></p>
</blockquote>
<p>Sounds obvious now, but it wasn’t obvious at 3 AM.</p>
<h3 id="heading-arm-vs-amd64-the-silent-killer">ARM vs AMD64 — the silent killer</h3>
<p>This was one of the most frustrating bugs because <strong>nothing looked wrong</strong>.</p>
<ul>
<li><p>My containers were building perfectly on my local machine.</p>
</li>
<li><p>Images were pushed to Docker Hub without any errors.</p>
</li>
</ul>
<p>But the moment I ran them on the VM, the container would just… die.</p>
<blockquote>
<p>“No stack trace. No meaningful log.“</p>
</blockquote>
<p>Just this cryptic line:</p>
<pre><code class="lang-bash"><span class="hljs-built_in">exec</span> format error
</code></pre>
<p>At first, I thought my code was broken. Then I thought my Dockerfile was wrong. Then I rebuilt the image. Then I rebuilt it again.</p>
<p>Nothing changed.</p>
<p>What I didn’t realise was that <strong>my local system and my VM spoke different languages</strong>. My local machine was building <strong>ARM-based images</strong>, while the VM expected <strong>AMD64</strong>. Docker didn’t scream. It didn’t warn loudly. It simply let me shoot myself in the foot. So the container technically existed — but the VM couldn’t execute it.</p>
<blockquote>
<p>“It felt unfair. Invisble. Almost evil.”</p>
</blockquote>
<p>Once I understood the root cause, the fix was simple. But reaching that understanding took hours. This was the moment I truly learned:</p>
<blockquote>
<p><strong>Deployment bugs are often not about code — they’re about context.</strong></p>
</blockquote>
<h3 id="heading-cors-issues-after-frontend-deployment">CORS issues after frontend deployment</h3>
<p>This one hurt in a very different way. Individually, everything worked:</p>
<ul>
<li><p>Backend APIs worked on the public IP</p>
</li>
<li><p>Frontend worked perfectly on Vercel</p>
</li>
<li><p>Requests succeeded in Postman</p>
</li>
</ul>
<p>But the moment I connect frontend to backend in the browser…</p>
<p><strong>Boom. CORS errors. Everywhere.</strong></p>
<p>The browser refused to cooperate. Requests weren’t even reaching my backend. At first, it felt ridiculous:</p>
<blockquote>
<p>“I’m hitting the same API that works in Postman. Why does the browser care?”</p>
</blockquote>
<p>That’s when reality hit. The browser doesn’t trust you. It doesn’t care that you wrote both frontend and backend. It enforces rules strictly.</p>
<blockquote>
<p>Different origins. Different ports. Different domains.</p>
</blockquote>
<ul>
<li><p>The backend was on a <strong>public IP with a port</strong> that was not secure (using <strong>‘http’</strong> instead of <strong>‘https’</strong>).</p>
</li>
<li><p>The frontend was on <strong>Vercel’s domain</strong>.</p>
</li>
</ul>
<p>Two different worlds.</p>
<p>What made this worse was that <strong>everything worked in isolation</strong>, which made debugging extremely misleading. I kept questioning my frontend code, then my backend routes, then my deployment again.</p>
<p>Only after properly understanding <strong>how CORS actually works</strong>, not just enabling it blindly, did things finally fall into place. I containerised the frontend also, created the image, pushed it to the Docker Hub, then pulled it in the VM and ran it on the same <strong>public IP</strong> with a different port.</p>
<p>This was my lesson:</p>
<blockquote>
<p><strong>If something works in Postman but not in the browser, it’s probably not your API.</strong></p>
</blockquote>
<h3 id="heading-containers-restarting-endlessly">Containers restarting endlessly</h3>
<p>One service failing meant Kafka retries. Kafka retries meant crashes. Crashes meant restarts. Restarts meant chaos.</p>
<p>I spent more time <strong>reading logs and restarting containers</strong> than writing code.</p>
<hr />
<h2 id="heading-the-turning-point-docker-compose">The Turning Point: Docker Compose</h2>
<p>At some point, I stopped and asked myself:</p>
<blockquote>
<p>“There has to be a better way.”</p>
</blockquote>
<p>That’s when I properly understood <strong>Docker Compose</strong>. Not as a buzzword — but as a <strong>solution to my exact pain</strong>.</p>
<p>Docker Compose lets you:</p>
<ul>
<li><p>Define all services in <strong>one file</strong></p>
</li>
<li><p>Start everything with <strong>one command</strong></p>
</li>
<li><p>Manage dependencies automatically</p>
</li>
<li><p>Restart services consistently</p>
</li>
</ul>
<p>Instead of manually running containers, I described my <strong>entire system</strong> in <code>docker-compose.yml</code>.</p>
<p>Kafka. Auth. User. Job. Utils. Client.</p>
<p>All connected. All defined.</p>
<h3 id="heading-one-command-changed-everything">One command changed everything</h3>
<p>Now my deployment flow looks like this:</p>
<ol>
<li><p>Make code changes</p>
</li>
<li><p>Build &amp; push updated image</p>
</li>
<li><p>SSH into VM</p>
</li>
<li><p>Run:</p>
<pre><code class="lang-bash"> docker compose pull
 docker compose up -d
</code></pre>
</li>
</ol>
<p>That’s it.</p>
<p>No stopping containers manually. No remembering ports. No running 10 commands.</p>
<p>The VM knows everything because <code>docker-compose.yml</code> <strong>is the source of truth.</strong></p>
<hr />
<h2 id="heading-what-this-project-actually-taught-me">What this project actually taught me</h2>
<p>This project didn’t just teach me Kafka or Docker; it taught me things that tutorials rarely emphasise:</p>
<ul>
<li><p><strong>Deployment is harder than development</strong></p>
</li>
<li><p>Logs are more important than code sometimes</p>
</li>
<li><p>“Working locally“ means almost nothing</p>
</li>
<li><p>Architecture decisions show their impact only in production</p>
</li>
<li><p>Tooling maturity matters as much as coding skills</p>
</li>
</ul>
<p>Most importantly, I learned that:</p>
<blockquote>
<p><strong>Real engineering starts when things break.</strong></p>
</blockquote>
<h2 id="heading-conclusion">Conclusion</h2>
<p>If you’re a student or a developer stuck rebuilding Docker images again and again — trust me, you’re not bad at this. You’re just <strong>learning the hard parts</strong>. And those hard parts?</p>
<p>They’re exactly what turns projects into <strong>experience</strong>. If I hadn’t struggled this much with NextHire, I would’ve learned far less. And honestly? I’d do it all over again.</p>
<blockquote>
<p><strong><em>💬 If you have any doubts, feel free to comment below or ask your queries — I’ll be happy to help!</em></strong></p>
</blockquote>
]]></content:encoded></item></channel></rss>