Webentra’s Post

⚠️ “My code is correct… but the API still doesn’t work!” If you’ve ever faced this, you’re not alone. API integration is one of the biggest challenges for students and beginners. 👉 Most common mistakes: 🔹 Using the wrong endpoint or URL 🔹 Missing authentication (API key / token) 🔹 Not handling JSON responses properly 🔹 Ignoring CORS issues 🔹 Writing code without testing the API first 💡 The truth: Good developers are not the ones who never face errors… They are the ones who know how to debug them effectively. 🎯 Smart approach: ✔ Test APIs using tools like Postman before coding ✔ Carefully read error messages in the console ✔ Understand status codes (200, 400, 500…) ✔ Debug step-by-step instead of guessing 🚀 API integration becomes easy when your debugging skills improve. 💬 Which API error frustrates you the most? --- #API #WebDevelopment #Developers #Programming #BackendDevelopment #FrontendDevelopment #FullStackDeveloper #Debugging #Coding #SoftwareDevelopment #TechCareers #LearningToCode #StudentLife #ProblemSolving #DevelopersLife #EngineeringStudents #TechEducation #SkillDevelopment

Recently, I accidentally fell into a rabbit hole… and instead of climbing out, I opened the source code of an AI coding agent 👀 I’ve been curious about agentic coding for a while, so I gave Opencode a spin. And yes, my selection criteria were extremely rigorous… mainly “ooh nice UI” and “that name sounds cool” 😄 While using it, I noticed something odd (atleast to me): It only listed my sessions when I was inside the same folder where they were created. Switching folders? No sessions. Naturally, curiosity kicked in — so I dug into the source code 🔍 Here’s what I found: 👉 Project Identification Opencode generates a unique project ID to track sessions. It does this in two ways:  - If the folder is a Git repo:      It runs   $ git rev-list --max-parents=0 HEAD       to get the Git directory, then derives the project identity from it.       And here’s the fun part — it caches this inside .git/opencode.   Yes, it casually writes into your .git folder. Pretty clever.  - If Git is not initialized:       It falls back to a constant global value (so basically, all such folders look the same to it, no because there are some other conditions too). 👉 Session Tracking Each session gets its own unique ID. 👉 How it links everything It stores sessions in a SQLite database and connects them using the project ID as a foreign key. You can even find where this DB lives with: opencode db path 💡 Why sessions don’t show across folders? Because each folder = different project ID (especially if Git is initialized). No shared project ID → no shared session list. Honestly, I love these small design decisions. Simple idea, clean implementation, and very “developer-minded.” Diving into source code like this always feels like uncovering tiny engineering stories hidden beneath the UI 🚀 #OpenSource #AI #AgenticAI #CodingAgent #DeveloperLife #SoftwareEngineering #TechDeepDive #CodeReading #LearnInPublic #Git #SQLite #Programming #Developers #TechCuriosity #BuildInPublic #EngineeringInsights #Debugging #DevTools #BackendEngineering #CleanDesign

Software engineering looks simple from the outside: 💻 write code 🐞 fix bugs 🚀 deploy updates But reality is different. A “small change” can quickly become: 🐛 one unexpected bug 🔌 one broken API response 🚨 one deployment issue 🧪 one edge case nobody tested 📩 one message saying: “can we add one more thing?” 😅 That’s why I’m learning to focus not just on writing code, but on building systems that are clean, reliable, and easier to maintain. For me, the real skill is debugging calmly, thinking through edge cases, automating repetitive work, and making sure the final solution actually works for real users. Still learning. Still improving. Still enjoying the chaos. ☕😂 #SoftwareEngineering #BackendDevelopment #Automation #NodeJS #APIs #Debugging #DeveloperLife #FullStackDevelopment

People often think of QML as just a scripting layer. I used to look at it the same way, until I actually started building with it. Coming from a backend dev mindset, I assumed this would be the easier side. Something lightweight on top while the real work happens in cpp. Not quite. QML has its own way of structuring things, state, components, data flow. And if you’ve worked with JavaScript, it feels oddly familiar. Dynamic, expressive, UI-first thinking. The real shift for me was seeing how cleanly it connects with the backend. Things like Q_PROPERTY and qmlRegisterType just bridge the gap so naturally, it almost feels seamless. Add to that property bindings reacting on their own and signals flowing across layers, and you start thinking very differently about how apps should behave. Also, QML lets you move fast while building. You just keep building. And then you run it. Runtime errors 🙂 Definitely not just a scripting layer. It’s a proper part of the stack, and easily one of the more interesting parts to work with. #Qt #QML #Cpp #EmbeddedDev #QtQuick #UI #CrossPlatformDev #DevThoughts

Some thing which is very underrated and actually important in software engineering is code deletion. YES, not creating new code, but code deletion. Deleting code is one of the most important things I learned during my journey of writing production code. As a junior, I thought my job was adding features. Every edge case got a new function. Years later, that codebase was an unmaintainable nightmare. Over time, I have realized that the best engineers aren't writing the most code, but they're deleting it. Our team once built a report exporter for PDF, Excel, CSV, JSON, and XML. Logs showed 99% of users only used PDF and Excel. The three unused formats took up 40% of the module's code and maintenance overhead. Despite team's pushback ("What if someone needs XML?"), we deleted them. We cut the module size by 40%, halved our bug rate, and shipped 30% faster. Not a single user noticed. Codebases fail because they have too many features. Obsolete features and "just in case abstractions" still require maintenance. Every line of code is a liability. It can break, it needs testing, and it adds complexity. The best code is no code. There are signs that one can look out for to decide whether you should delete code: - Low usage: Less than 5% adoption after six months. - Forgotten origins: You have to dig through git history to understand why it exists. - Spaghetti logic: It scatters if statements across the codebase. - Test bloat: The tests are more complex than the implementation. - Fear: Developers avoid touching it because it might break. I now do a quarterly codebase purge, where in lookout for unused features. There are expected pushback: "We might need it." - It’s in Git. You can bring it back in an hour. "We spent time on it." - Sunk cost fallacy. "It’s not hurting anything." - It is. It makes the system harder to maintain. Your job as an engineer isn't just to write code. It is to solve problems. That often means deleting code to make systems simpler and more reliable. Next time you're about to add a feature, ask yourself: "Do I really need a new functionality OR can we enhance on the existing functionality.?" #coding #softwaredev #software #production

Atomic Habits breaks every habit into 4 steps. Cue, craving, response, reward. The cue triggers your brain. The craving motivates you. The response is the action you take. The reward reinforces the loop. I mapped my own coding habit to this today. 🔵 Cue: I open my laptop every morning at the same time. 🔥 Craving: I want to feel like I am making progress. ⚡ Response: I write code, solve DSA problems, learn something new. ✅ Reward: The feeling of having built something real by end of day. Today that response was understanding JavaScript control flow deeply, loops, early return patterns and why they matter beyond just syntax. Also dug into GitHub API integration using shell scripts for DevOps. Solved 5 DSA problems. The book also says to break a bad habit, make it invisible, unattractive, difficult and unsatisfying. Small friction. Big difference. Day 2 of showing up publicly. 🚀 #100DaysOfCode #JavaScript #DSA #LearningInPublic #SoftwareEngineering

𝗦𝗽𝗲𝗻𝘁 𝘁𝗵𝗲 𝗹𝗮𝘀𝘁 𝘄𝗲𝗲𝗸 𝗱𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 𝗮 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗶𝘀𝘀𝘂𝗲 𝘁𝗵𝗮𝘁 𝗰𝗮𝗺𝗲 𝗱𝗼𝘄𝗻 𝘁𝗼 𝗼𝗻𝗲 𝘁𝗵𝗶𝗻𝗴 — 𝗮 𝗽𝗼𝗼𝗿𝗹𝘆 𝘄𝗿𝗶𝘁𝘁𝗲𝗻 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲. 𝗦𝗼 𝗵𝗲𝗿𝗲 𝗮𝗿𝗲 𝘁𝗵𝗲 𝗗𝗼𝗰𝗸𝗲𝗿 𝗯𝗲𝘀𝘁 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 𝗜 𝘄𝗶𝘀𝗵 𝘀𝗼𝗺𝗲𝗼𝗻𝗲 𝗵𝗮𝗱 𝘁𝗼𝗹𝗱 𝗺𝗲 𝗲𝗮𝗿𝗹𝗶𝗲𝗿: 𝟭. 𝗨𝘀𝗲 𝗮 𝘀𝗽𝗲𝗰𝗶𝗳𝗶𝗰 𝗯𝗮𝘀𝗲 𝗶𝗺𝗮𝗴𝗲 𝘁𝗮𝗴, 𝗻𝗲𝘃𝗲𝗿 :𝗹𝗮𝘁𝗲𝘀𝘁  latest can silently change between builds. Pin your version — node:20.12-alpine, python:3.12-slim. Your future self will thank you. 𝟮. 𝗢𝗿𝗱𝗲𝗿 𝘆𝗼𝘂𝗿 𝗹𝗮𝘆𝗲𝗿𝘀 𝗳𝗿𝗼𝗺 𝗹𝗲𝗮𝘀𝘁 𝘁𝗼 𝗺𝗼𝘀𝘁 𝗳𝗿𝗲𝗾𝘂𝗲𝗻𝘁𝗹𝘆 𝗰𝗵𝗮𝗻𝗴𝗲𝗱  COPY package.json first → RUN npm install → then copy the rest of your code. This keeps your dependency layer cached and builds stay fast. 𝟯. 𝗥𝘂𝗻 𝗮𝘀 𝗮 𝗻𝗼𝗻-𝗿𝗼𝗼𝘁 𝘂𝘀𝗲𝗿  By default, containers run as root. That's a security risk. Add: RUN adduser --disabled-password appuser USER appuser 𝟰. 𝗨𝘀𝗲 .𝗱𝗼𝗰𝗸𝗲𝗿𝗶𝗴𝗻𝗼𝗿𝗲  Stop shipping node_modules, .git, test files, and .env into your images. A bloated image is a slow image — and a leaky one. 𝟱. 𝗠𝘂𝗹𝘁𝗶-𝘀𝘁𝗮𝗴𝗲 𝗯𝘂𝗶𝗹𝗱𝘀 𝗮𝗿𝗲 𝗮 𝗴𝗮𝗺𝗲 𝗰𝗵𝗮𝗻𝗴𝗲𝗿  Build your code in one stage, copy only the final artifact to a clean runtime image. I've seen image sizes go from 1.2GB → 80MB just from this one change. 𝟲. 𝗢𝗻𝗲 𝗽𝗿𝗼𝗰𝗲𝘀𝘀 𝗽𝗲𝗿 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿  Don't run your app + cron + nginx in a single container. Separate concerns. Use docker-compose or orchestration for that. 𝟳. 𝗛𝗘𝗔𝗟𝗧𝗛𝗖𝗛𝗘𝗖𝗞 𝗶𝘀 𝗻𝗼𝘁 𝗼𝗽𝘁𝗶𝗼𝗻𝗮𝗹 𝗶𝗻 𝗽𝗿𝗼𝗱  HEALTHCHECK --interval=30s --timeout=5s CMD curl -f http://localhost:8080/health || exit 1 If you're not doing this, your orchestrator doesn't know if your app is actually alive.  • 𝗦𝗺𝗮𝗹𝗹 𝗶𝗺𝗽𝗿𝗼𝘃𝗲𝗺𝗲𝗻𝘁𝘀 𝗶𝗻 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲𝘀 𝗰𝗮𝗻 𝘀𝗮𝘃𝗲 𝗵𝗼𝘂𝗿𝘀 𝗶𝗻 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻. #Docker #DevOps #SoftwareEngineering #Backend #CloudNative

⚡ Post 6 of 7 — Performance & Accuracy: Run Faster Without Breaking Things A test suite that takes 3 hours to run is a test suite nobody waits for. Here's how programming fundamentals directly speed things up: ───────────────────── 1️⃣ Parallel Execution → Cut Execution Time Drastically Running 100 tests one by one? Slow. Running them in parallel threads? 4x–10x faster. But parallelism only works safely when your code is thread-safe — no shared mutable state between tests. This is pure programming knowledge applied to QA. Impact → Faster feedback. Faster CI/CD pipelines. ───────────────────── 2️⃣ Lazy Initialization → Don't Load What You Don't Need Initializing every page object at test start wastes memory. Lazy loading creates objects only when they're actually needed. Impact → Lower memory usage. Faster test startup. ───────────────────── 3️⃣ Explicit Waits Over Thread.sleep() → Accuracy Over Guessing Thread.sleep(3000) is a guess. Explicit waits wait for the exact condition — element visible, clickable, present. Impact → Faster tests. Zero unnecessary waiting. Fewer flaky failures. ───────────────────── 4️⃣ Data-Driven Testing → One Test, Infinite Scenarios Instead of writing 10 tests for 10 inputs — write one test, feed it 10 data sets. Impact → Maximum coverage. Minimum code. 📌 Performance in QA isn't just about fast internet or good machines. It's about writing smart code. Final post coming → How everything ties together 🎯 #Performance #QAAutomation #Java #Playwright #SoftwareTesting #TestAutomation #LearningInPublic

Me: "This will take 2 hours" Also me 6 hours later: Still debugging why my code works perfectly on my machine but crashes spectacularly in production. The plot twist? A missing environment variable I confidently set 3 months ago and completely forgot about. We've all been there. That sinking feeling when your "quick fix" turns into an archaeological dig through your own code. You question everything: • Is Docker lying to me? • Did I break the entire CI/CD pipeline? • Why didn't I document this better? • Was I drunk when I wrote this? Then you find it. One tiny DATABASE_URL sitting in your local .env file, mocking you. The variable you added during that late-night coding session when you were "just testing something real quick." The worst part? You spend 30 seconds adding it to production and everything works flawlessly. Time estimation in software development is already hard enough without our past selves setting traps for our future selves. What's the most ridiculous production bug you've spent hours debugging, only to find an embarrassingly simple fix? #viral #trending #trend #coding #programming #developer #softwaredeveloper #webdev #debugging #production #environment #variables #deploymentfails #developerlife #tech #javascript #python #docker

What is Postman and why do developers use it? When building APIs, you need a way to test them without relying on a frontend application. This is where Postman becomes essential. Postman is a tool that allows you to send HTTP requests to your API and inspect the responses. Instead of writing code just to test an endpoint, you can interact with your backend directly. Key idea: Postman helps you test and debug APIs quickly. Example: If you build an endpoint like: GET /users You can use Postman to send a request to that endpoint and instantly see: the returned data the status code (200, 404, etc.) headers and response time Why it matters: speeds up development by testing endpoints independently helps debug errors in your API allows you to experiment with different requests (GET, POST, PUT, DELETE) useful for working with teams by sharing API collections In simple terms: Postman is a bridge between you and your API, allowing you to understand exactly how your backend behaves. If you are building backend systems with tools like FastAPI, learning Postman is not optional, it is a core skill. #programming #backend #api #webdevelopment #python