DEV Community: Divyanshi Sain

5 Mistakes Every Developer Makes When Using LLM APIs for the First Time

Divyanshi Sain — Thu, 04 Jun 2026 11:42:06 +0000

You write a few lines of code. You call the API. It responds. Everything feels effortless.

Then 48 hours later everything falls apart. Your app throws errors you cannot explain. Your token costs are out of control. And the model keeps returning outputs that break your application logic.

This is not bad luck. This is the pattern.

A 2025 Stack Overflow survey found that over 84% of developers are now using AI tools in their workflow. But the same report highlighted that most developers struggle with reliability, cost control and debugging when working with LLM APIs for the first time. The quickstart docs get you to your first response in minutes. They do not prepare you for what comes next.

LLM APIs are fundamentally different from anything you have worked with before. They are probabilistic, not deterministic. They are billed by tokens, not requests. A single wrong assumption can cost you hours in debugging or dollars in wasted API calls.

I have made every mistake on this list. So has almost every developer who picked up an LLM API without a proper foundation. These five LLM API mistakes developers make are the ones that hurt the most and cost the most. Knowing them before you build will save you real time and real money.

Let us get into it.

The 5 Most Common LLM API Mistakes Developers Make

Every developer hits these walls. Some in testing. Some in production. Here are the five mistakes you need to know before you ship anything.

Mistake 1: The Token Trap (Ignoring Token Limits Until It Breaks Your App)

Every LLM API has a context window. This is the maximum number of tokens the model can process in one request. Tokens are not words. One word can be one token or several. If your input plus expected output exceeds this limit the API throws an error or cuts off the response mid-sentence. This never shows up in testing. It shows up in production in front of real users.

How to fix it: Track token usage from day one. Log the token counts the API returns. Trim older messages from chat history before sending a new request. You do not need the full conversation. You just need enough context.

Mistake 2: The Vague Prompt Problem (Writing Vague Prompts and Expecting Smart Outputs)

You send "summarise this" and get a response that kind of works but not really. So you try again. Each attempt costs tokens and time. The model is not guessing. It is predicting based on what you gave it. Give it very little and it has very little to work with.

How to fix it: Be specific. Instead of "summarise this article" try "summarise this article in three bullet points for a beginner developer. Avoid technical jargon." The more context you give the better the output.

Mistake 3: The Silent Crash (Not Handling API Errors and Rate Limits)

You call the API. It works. So you assume it always will. Then you hit a rate limit. Or a 500 error. Or a timeout. And because you never built errors handling your entire app crashes.

How to fix it: Wrap every API call in a try-catch block. Add retry logic with exponential backoff. If the first request fails, wait one second. Then two. Then four. Rate limits are not bugs. They are boundaries. Build for them.

Mistake 4: The Hidden Cost Killer (Sending the Entire Conversation History Every Time)

Every new message you send includes the full chat history. In a short conversation this is fine. In a long one you are sending thousands of tokens every single time. A 30-minute conversation can easily hit 4000 tokens of history. Multiply that across hundreds of users and your API bill explodes.

How to fix it: Use a sliding window. Keep only the last N messages. Or summarise older parts of the conversation before sending. Understanding training vs inference explained for developers helps you see exactly why every token you send costs real money. This one change can cut your API costs by 40 to 60 percent.

Mistake 5: The Blind Trust Mistake (Skipping Output Validation)

The API returned something. You assumed it was correct. You passed it directly into your app. Then something broke downstream. LLM outputs are not guaranteed. The model might return extra text before your JSON. It might miss a required field. It might wrap output in markdown when you ask for plain text.

How to fix it: Always validate output before using it. Parse JSON inside a try-catch. Use structured output features where available. OpenAI and Claude both support JSON schema enforcement. Use them. Treat model output like user input. Never trust it blindly.

Quick Reference: LLM API Best Practices Checklist

Before you ship anything, run through this list. These seven things will save you from the most common and costly mistakes.

1. Track How Many Tokens You Are Using: Most developers ignore this until the bill arrives. Check your token count on every request.

2. Write Clear and Specific Prompts: Vague prompts give vague results. Tell the model exactly what you want and how you want it.

3. Handle Errors Before They Crash Your App: The API will fail sometimes. Rate limits happen. Timeouts happen. Build for it from day one.

4. Stop Sending the Full Chat History Every Time: Long conversations send thousands of tokens on every request. Use a sliding window to keep costs low.

5. Always Check What the Model Sends Back: Never pass raw model output directly into your app. Validate the format before you use it.

6. Log Every API Call: When something breaks in production you will thank yourself for keeping logs. Track prompt size, response size and response time.

7. Set a Cost Alert Right Now: Go to your API dashboard and set a spending limit today. Do not wait for a surprise bill to do it.

The Mistake Nobody Talks About: Not Learning How LLMs Actually Work

All five mistakes above have a common root. Most developers start calling the API before they truly understand how LLMs work. They treat it like a search engine or a database. It is neither.

When you understand that the model predicts tokens based on patterns and that every word you send costs money and affects the output you naturally start making better decisions. You write tighter prompts. You manage context more carefully. You stop expecting deterministic behaviour from a probabilistic system.

If you want to fix that gap from the ground up AI courses in Jaipur give you the practical foundation that no quickstart doc ever will. What every developer should know before using LLM APIs is not just syntax. It is how the model actually thinks. That foundation changes everything about how you build.

Conclusion

Most developers do not fail with LLM APIs because the technology is hard. They failed because nobody told them what to watch out for before they started building.

Now you know the five mistakes that cost developers the most time and money. Tokens, prompts, error handling, conversation history and output validation. These are not advanced concepts. They are the basics that quickstart docs always skip.

Go back to the checklist. Fix what is missing. Then ship with confidence.

The API is ready. Now you are too.

How to Build Your First REST API in Node.js ?

Divyanshi Sain — Wed, 27 May 2026 12:37:42 +0000

Most beginners think building a backend is complicated. It looks scary from the outside. Servers, routes, databases, requests, responses, it feels like a lot. But here is the truth. Building your first REST API in Node.js is simpler than you think. You just need the right guide and a willingness to write some code.

This article is a complete Node.js REST API tutorial for absolute beginners in 2026. Are you a student building your first portfolio project? A hackathon participant who needs a strong backend? Or a developer who wants to understand how APIs actually work? This guide is for you.

By the end of this article you will have a working REST API running on your machine. You will understand every line of code you wrote. And you will be ready to take it further.

Let us get started.

What is a REST API and Why Should You Care?

Before you build something you need to understand what it actually is.

Imagine you are using a weather app on your phone. You open the app and it shows you today's temperature. Where does that data come from? The app does not store weather data itself. It sends a request to a server and the server sends back the data. The app displays it.

That communication between the app and the server happens through an API. API stands for Application Programming Interface.

REST stands for Representational State Transfer. It is a set of rules that makes this communication simple, clean and consistent. When an API follows these rules we call it a REST API.

Here is why REST APIs matter for you as a developer or project builder:

Almost every modern application uses REST APIs
They are the backbone of mobile apps, web apps and microservices
Understanding REST APIs opens the door to full stack and backend development
Hackathon projects with a solid API backend always stand out

Now let us build one.

What You Need Before You Start

This is a beginner friendly guide but you need a few things installed on your machine before we write any code.

Requirements:

Node.js: Download it from nodejs.org. Install the LTS version.

npm: It comes with Node.js automatically. No separate install needed.

Postman: A free tool to test your API. Download it from postman.com.

A code editor: VS Code works best. Download it from code.visualstudio.com.

Basic JavaScript knowledge: You should know variables, functions and how arrays work.

That is all you need. No advanced setup. No paid tools.

Setting Up Your Node.js Project

Open your terminal and follow these steps one by one.

Step 1: Create a new project folder
mkdir my-first-api
cd my-first-api

Step 2: Initialise your Node.js project
npm init -y

This creates a package.json file. It tracks your project details and dependencies.

Step 3: Install Express
Express JS is the most popular framework for building a Node.js Express REST API. It makes routing simple and saves you a lot of time.

npm install express

Step 4: Create your main file
touch index.js

Your project structure now looks like this:

my-first-api/
├── node_modules/
├── package.json
└── index.js

You are ready to write your first API.

Building Your First Route with Express

Open index.js in your code editor and write the following code:

const express = require('express');
const app = express();
const PORT = 3000;

// Middleware to parse JSON
app.use(express.json());

// Your first route
app.get('/', (req, res) => {
  res.json({ message: 'Welcome to my first REST API!' });
});

// Start the server
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

Now run your server:
node index.js

Open your browser and go to http://localhost:3000. You will see:
{
  "message": "Welcome to my first REST API!"
}

Congratulations. You just built your first working route. This is the foundation of every REST API in Node.js. A server that listens for requests and sends back responses.

Understanding HTTP Methods GET POST PUT DELETE

Every REST API uses HTTP methods to define what action you want to perform. This is one of the most important concepts in backend development for beginners.

Here is a simple breakdown:

HTTP Method	What It Does	Real World Example
GET	Fetch or read data	Get a list of all users
POST	Create new data	Add a new user
PUT	Update existing data	Update a user's email
DELETE	Remove data	Delete a user account

Let us build a simple CRUD REST API in Node.js Express using these four methods. We will use an in-memory array to store data for now.

// Sample data
let users = [
  { id: 1, name: 'Rahul Sharma', email: 'rahul@example.com' },
  { id: 2, name: 'Priya Verma', email: 'priya@example.com' }
];

// GET — Fetch all users
app.get('/users', (req, res) => {
  res.json(users);
});

// GET — Fetch single user by ID
app.get('/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).json({ message: 'User not found' });
  res.json(user);
});

// POST — Add a new user
app.post('/users', (req, res) => {
  const newUser = {
    id: users.length + 1,
    name: req.body.name,
    email: req.body.email
  };
  users.push(newUser);
  res.status(201).json(newUser);
});

// PUT — Update a user
app.put('/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).json({ message: 'User not found' });
  user.name = req.body.name || user.name;
  user.email = req.body.email || user.email;
  res.json(user);
});

// DELETE — Remove a user
app.delete('/users/:id', (req, res) => {
  users = users.filter(u => u.id !== parseInt(req.params.id));
  res.json({ message: 'User deleted successfully' });
});

You now have a complete set of CRUD operations. This is the core of almost every real world API.

Sending a Proper JSON Response

Every modern REST API communicates using JSON — JavaScript Object Notation. It is lightweight, readable and universally supported.

A proper Node.js JSON response always includes two things — a status code and a data payload.

Here are the most common status codes you will use:

Status Code	Meaning
200	Success - request worked fine
201	Created - new resource added
400	Bad Request - something wrong with input
404	Not Found - resource does not exist
500	Server Error - something broke on the server

Always send meaningful status codes with your responses. It makes your API easier to use and debug.

How to Test Your API with Postman

Writing code is only half the work. You need to test it properly. This is where Postman comes in.

Postman lets you send HTTP requests to your API without building a frontend. It is the most popular tool to test REST API with Postman and every backend developer uses it daily.

How to test your API:

Open Postman
Click New Request
Select the HTTP method (GET, POST, PUT, DELETE)
Enter your URL — for example http://localhost:3000/users
For POST and PUT requests click Body → select raw → choose JSON
Enter your JSON data and click Send

Example POST request body:

{
  "name": "Amit Singh",
  "email": "amit@example.com"
}

You will see the response appear instantly in Postman. Test every route you build. Do not skip this step.

Connecting Your API to a Database

Right now your data lives in an array. When you restart the server everything resets. For a real project you need a database.

The most popular choice to connect Node.js REST API to MongoDB is MongoDB with Mongoose.

Install the required packages:
npm install mongoose

Connect to MongoDB in your index.js:

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/myapi')
  .then(() => console.log('MongoDB connected'))
  .catch(err => console.log('Connection error:', err));

Create a User model:

const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true }
});

const User = mongoose.model('User', userSchema);

Now replace your array-based routes with database operations using User.find(), User.create(), User.findByIdAndUpdate() and User.findByIdAndDelete().

This small addition transforms your simple project into a production-ready backend.

How to Handle API Errors the Right Way

Most beginners build routes that work when everything goes right. But real applications break. Users send wrong data. Records do not exist. Servers go down.

Learning how to handle API errors in Node.js is what separates a beginner project from a professional one.

Add a global error handler at the bottom of your index.js:

// Handle routes that do not exist
app.use((req, res) => {
  res.status(404).json({ message: 'Route not found' });
});

// Handle all other errors
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ message: 'Something went wrong on the server' });
});

Always validate incoming data before processing it. Always return clear error messages. Always use correct status codes.

REST API Best Practices Every Beginner Should Follow

Before you ship your API to a hackathon or add it to your portfolio follow these REST API best practices:

Use clear and consistent route names. Use nouns not verbs. /users is correct. /getUsers is not.
Always version your API Start with /api/v1/users. This makes future updates easier without breaking existing integrations.
Use correct HTTP status codes. Never return a 200 for an error. Always match the status code to the result.
Validate all incoming data. Never trust user input. Always check that required fields exist before saving to the database.
Keep your code organised. Separate your routes, controllers and models into different files as your project grows.
Never expose sensitive data. Do not return passwords or internal server details in your API responses.

These practices make your API clean, reliable and ready for real use.

Your API is Ready: What Comes Next

You just completed a full Node.js REST API tutorial for absolute beginners. You built a working server, created CRUD routes, handled errors, tested with Postman and connected to a database.

This is exactly how to build a REST API in Node.js step by step for beginners — and now you have done it yourself.

But this is just the beginning. Here is what you can explore next:

Add authentication: Learn JWT tokens to protect your routes.
Deploy your API: Use Railway, Render or Vercel to deploy your Node.js REST API for free on the internet.
Add input validation: Use the express-validator package to validate data properly.
Learn more about MongoDB: Build more complex queries and relationships between collections.

If you are building this for a hackathon, add a frontend with React or plain HTML and connect it to your API. Your project will immediately look more complete and impressive to judges.

The best way to get better at backend development for beginners is to keep building. Take this foundation, extend it, break it, fix it and build something you are proud to showcase.

You already have everything you need to start.

The 12 VS Code Extensions That Actually Made Me Faster in 2026

Divyanshi Sain — Wed, 20 May 2026 12:08:53 +0000

I tried more than forty VS Code extensions while working on full stack projects this year. Most of them slowed me down or added no real value. Only twelve made my workflow faster and earned a permanent spot.

This post is not another random list from the marketplace. Each extension here passed one clear test - it saved me time or solved a real problem while I was writing code.

Let’s look at the twelve that truly helped me work better.

1. GitHub Copilot

Copilot stopped being optional in 2026. It writes boilerplate, suggests entire functions and explains code I did not write. The 2026 version handles multi-file context far better than older releases.

I use it most for writing test cases and converting plain English into working code blocks.

Why it stays: It saves me roughly two hours every day on repetitive code.

Pro tip: Press Ctrl+I for inline chat. This shortcut alone changed how I refactor.

2. GitLens

GitLens turns every line of code into a story. Hover over any line and you see who wrote it when they wrote it and why. The blame annotations are not just for finding who broke production. They help me understand legacy code faster.

The 2026 update added AI commit summaries which actually work.

Why it stays: Code archaeology becomes effortless.

3. Prettier

Prettier ends every formatting debate inside a team. You set the rules once and the extension enforces them on save. My students stop arguing about semicolons and tabs versus spaces within a week.

Add this to your settings.json:

json
{
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode"
}

Why it stays: Zero brain cycles spent on style.

4. ESLint

ESLint catches bugs before you run your code. Unused variables, wrong types, broken promises. ESLint flags all of it inside the editor in real time.

Pair it with Prettier and your code becomes both clean and correct.

Why it stays: It prevents bugs I would otherwise ship.

5. Thunder Client

Thunder Client replaced Postman in my workflow. It runs API requests directly inside VS Code so I stop switching windows fifty times an hour. The free tier handles everything I need for full stack work.

The collection sync feature lets my team share API requests through Git.

Why it stays: One less app on my Mac and one less context switch.

6. Live Server

Live Server still earns its place in 2026. Open any HTML file right click and select Open with Live Server. Your browser reloads on every save. For students learning the front end this extension removes the entire build setup hurdle.

Why it stays: Instant feedback loop for HTML CSS and vanilla JavaScript.

7. Tailwind CSS IntelliSense

If you write Tailwind without this extension you are punishing yourself. It autocompletes class names, previews colors inline and warns when you misspell utilities.

Why it stays: Tailwind without IntelliSense feels like coding blindfolded.

8. Path Intellisense

This one surprised me with how much it saves. Type a file path and Path Intellisense suggests files and folders as you type. No more typos in import statements. No more wrong relative paths.

Why it stays: Tiny extension. Huge daily impact.

9. Error Lens

Error Lens displays errors and warnings inline next to the actual code. Most developers run their cursor over a red squiggle and read the popup. Error Lens shows the message right next to the line.

This single change made my debugging twice as fast.

Why it stays: Errors become impossible to ignore.

10. Dev Containers

Dev Containers killed the work on my machine problem for my team. Define your dev environment once inside a container. Every teammate opens the project and gets the same Node version, the same dependencies and the same database setup.

New hires now start coding within thirty minutes instead of two days.

Why it stays: Onboarding pain disappears.

11. Auto Rename Tag

You rename an opening HTML tag and the closing tag updates automatically. Sounds small. Saves hundreds of edits a week if you write JSX or HTML daily.

Why it stays: Pure quality of life.

12. Better Comments

Better Comments color codes your comments by type. Questions show up orange warnings show up red and TODOs show up blue. Reading your own code from six months ago has become much easier.

Add these markers:

`js
// ! Critical warning
// ? Open question
// TODO: needs refactor
// Important note

Why it stays: Comments become scannable.

The Honest Section: Three Extensions I Removed

I want to be straight with you. Some popular extensions did not survive my workflow this year.

Bracket Pair Colorizer: VS Code now does this natively. Uninstall it.

Code Spell Checker: Useful in theory but the false positives drove me crazy.

Live Server Preview: Slower than the original Live Server. Stick with the classic.

How I Set Up VS Code for Maximum Speed

Three settings made the biggest difference in my daily speed.

Disable extensions per workspace. Heavy extensions like Docker do not need to run inside a React project. Right click any extension in the sidebar and select Disable for this Workspace.

Use the Performance view. Open the command palette and run Developer: Show Running Extensions. Anything taking over 100ms to activate is a candidate for removal.

Sync settings across machines. Sign in to VS Code with your GitHub account and turn on Settings Sync. Your extensions keybindings and themes follow you to every laptop.

Quick Recommendations by Developer Type

If you are a front end developer install Tailwind IntelliSense Live Server Auto Rename Tag and Error Lens first.

If you are a back end developer install Thunder Client GitLens Dev Containers and Prettier first.

If you are a full stack developer install all 12 and never look back.

If you are a complete beginner install GitHub Copilot Live Server Prettier and Error Lens. Skip the rest until you build at least three projects.

Final Thoughts

The right extensions do not just save seconds. They remove friction so you stay in flow. My output doubled this year and I credit roughly half of that gain to a properly configured VS Code.

Test these one at a time. Add an extension. Use it for a week. Decide if it earns a spot. Reject anything that slows your editor or distracts you.

What VS Code extensions earned a permanent spot in your workflow this year? Drop them in the comments. I am always hunting for the next hidden gem.

I train developers at TISA-TECH in Jaipur where we teach full stack and AI integrated development. If you are learning to code and want structured mentorship feel free to drop a question in the comments. Always happy to help.