Forem: Abdullah Jawed

Express API's

Abdullah Jawed — Sat, 29 Nov 2025 10:13:20 +0000

Let’s Make Express APIs Easy (GET, POST, PUT, DELETE Explained)

If you’re learning backend development and feeling confused about APIs, trust me you’re not alone.
When I first started with Express, even simple words like routes, endpoints, methods felt scary.

But once you understand four simple methods, everything becomes clear:

👉 GET
👉 POST
👉 PUT
👉 DELETE

That’s literally all you need to build a basic backend.

So let’s break it down in the simplest, rawest way possible.

What Even Is an API?

Think of an API like a waiter in a restaurant.

You (the client) ask something →
Waiter (API) takes your request →
Kitchen (server) sends the food back.

Express just makes it easy to be that “waiter.”

1. GET — “Give me the data”
GET is the easiest.
When the frontend wants something, it uses GET.

Example:


app.get(”/users”, (req, res) => {
    let alluser = readDB()
    res.status(200).json(alluser);
});

You’re basically saying:

“Hey server, give me all the users.”

No body, no extra stuff — just fetch data.

Real use cases:

Show all products
Get user profile
Display a dashboard

2. POST — “I want to create something”
POST is used when you’re sending data to the backend.

Example:

  const { name, email } = req.body;
  if (!name || !email) {
    return res.status(400).json({ success: false, message: “name and email required” });
  }
  const id = users.length ? users[users.length - 1].id + 1 : 1;
  const newUser = { id, name, email };
  users.push(newUser);
  res.status(201).json({ success: true, data: newUser });
});Frontend sends something like:
{
  “name”: “Abdullah”,
  “email”: “abdullah@gmail.com”
}

And backend stores it.

Real use cases:

Register a user
Submit a form
Add a blog post

3. PUT — “Replace the whole thing”
PUT is for updating — but remember this:

👉 PUT replaces the entire object, not just one part.

Example:


router.put(”/users/:id”, (req, res) => {
  const id = Number(req.params.id);
  const { name, email } = req.body;
  const idx = users.findIndex(u => u.id === id);
  if (idx === -1) return res.status(404).json({ success: false, message: “User not found” });

  // replace object (PUT semantics)
  users[idx] = { id, name: name ?? users[idx].name, email: email ?? users[idx].email };
  res.json({ success: true, data: users[idx] });
});

If you update a user using PUT, you’re basically saying:

“Here is the full updated user object. Replace everything with this.”

Real use cases:

Edit full profile
Update product details
Replace blog post content

4. DELETE — “Remove this immediately”

DELETE does exactly what the name says.

Example:


router.delete(”/users/:id”, (req, res) => {
  const id = Number(req.params.id);
  const idx = users.findIndex(u => u.id === id);
  if (idx === -1) return res.status(404).json({ success: false, message: “User not found” });

  const removed = users.splice(idx, 1)[0];
  res.json({ success: true, data: removed });
});

Use it when you want to remove something:

Delete an account
Remove a product
Delete a comment
Remove a file

Trading in the Age of Developers

Abdullah Jawed — Sun, 23 Nov 2025 09:40:07 +0000

“When algorithms started trading faster than traders, a new era was born, the era of Dev Traders.”

Let’s be honest:- Trading looks exciting from the outside.

You see charts moving, candles jumping, people making money with a single click.
But the moment you actually step into trading, you realize something painful:

It’s not as simple as buying low and selling high.

So in this blog, I want to start from the absolute basics of trading, the way a real beginner understands it.
And then slowly move toward how coding enters this world and why so many traders today are turning into developer-traders.

1. What Even Is Trading? (Let’s Start Like a Real Beginner)

Trading is nothing fancy.
It’s basically this:

You buy something for cheap
You sell it for higher
Or you sell it high first, buy it back lower (yes, that’s possible)
The “something” can be:
Forex pairs (Gold, GBPUSD, EURUSD)
Crypto (BTC, ETH)
Stocks
Commodities

That’s it.
Nothing mysterious.

2. Why Most People Lose Money (The Bitter Truth)

Every beginner thinks they’ll become profitable by watching a few YouTube videos and learning some patterns.

Reality hits differently.

You enter a trade too early.
You exit too late.
You get scared.
You get greedy.
You swear you’ll follow your plan but the moment price moves fast, your brain stops working.

It’s not the market that beats you.
It’s your emotions.

This is the part nobody warns you about.

3. Where Technology Enters And Saves Us

At some point, every trader realizes this:

“I know what to do… I just don’t do it consistently.”

That’s where technology changes the whole game.

Unlike humans, a bot doesn’t:

Overthink
Hesitate
Overtrade
Break rules
Take revenge trades
Sleep
Panic during news

A bot simply executes the plan.

Every. Single. Time.

That’s why algo trading and automated systems exist not to make traders lazy, but to make them disciplined.

4. So How Does Coding Connect With Trading?

This is the part most beginners misunderstand.

Coding in trading isn’t about being a genius or writing 10,000 lines of code.
It’s simple:

You convert your trading rules into logic the computer can understand.

Example:

If RSI goes below 30 → BUY
If EMA 50 crosses EMA 200 → Trend change
If price touches demand zone → Look for entries
If equity drops 5% → Stop trading
If news is coming → Pause trades
This logic can be written in:
MQL5 (for MT5 robots)
Pine Script (for TradingView indicators)
Python (for crypto bots & analysis)

That’s it.

Coding is basically telling your strategy:
“Do this automatically, without my emotions.”

5. A Very Real Example (This Will Make Sense)

Let’s say your manual strategy is:

Buy when 50 EMA crosses above 200 EMA

RSI must be below 60

Risk 1%

Reward 3%

When you trade manually:

You stare at the chart
You wait forever
You enter late
You exit early
You get scared
You miss 50% setups

Now imagine putting these rules into code.

You write your logic once…
The EA runs it forever.

It doesn’t care if you’re tired.
It doesn’t care if you’re emotional.
It doesn’t care if it’s 3:00 AM.

It will follow your rules even better than you do.

6. The Real Advantage of Being a Dev Trader

When you know both trading and coding, something interesting happens:

You no longer depend on random indicators
You stop searching for “perfect strategy”
You build your own tools
You fix your strategy mistakes through logic
You backtest fast
You automate boring tasks
You trade like a machine And you gain a MASSIVE edge over others

Most traders are guessing.
Dev traders are building.

Most traders wait for signals.
Dev traders create signals.

Most traders react.
Dev traders prepare.

This is the difference that separates average traders from scalable ones.

7. The Future Is Very Clear

Look around.

Hedge funds use algorithms.
Banks use algorithms.
Prop firms use algorithms.

Retail traders using pure emotions?
They are playing on “easy mode” while institutions play on “god mode.”

If you want to survive in the next 5–10 years of financial markets, you must learn:

Logic
Automation
Coding
Strategy building
Data analysis Because the truth is simple:

The future of trading is automated.
The future of traders is developers.

Summary

You don’t need to become a coding expert on day one.
You just need to understand that trading is moving toward automation — and those who adapt early will win big.

Start with basics.
Learn the market.
Build simple rules.
Turn rules into logic.
Then automate.

This journey can turn you from a normal trader into someone who can build systems that make money while you sleep.

And that’s the real power of connecting trading + coding.