DEV Community: Rakibul islam

New HTTP QUERY Method (RFC 10008) Explained | Stop Using POST for Search

Rakibul islam — Wed, 05 Aug 2026 09:14:47 +0000

Introduction

In June 2026, the IETF published RFC 10008 - the first new general-purpose HTTP method since PATCH was introduced in 2010.

The method is called QUERY.

In simple terms:

QUERY = Safety of GET + Body of POST

You can now send complex search/filter queries in the request body, while the server knows the operation is safe and idempotent. This means caching, automatic retries, and CDNs can all work properly.

This single change can finally end the long-standing practice of using POST for search.

The Problem We Had

1. Limitations of GET

With GET, query parameters go in the URL:

GET /products?category=electronics&price_min=1000&price_max=50000&brand=samsung,apple&sort=-rating&page=1&limit=20

When filters become complex (JSON filters, nested conditions, many tags), the URL easily exceeds 8,000 characters. Many servers, proxies, and browsers struggle with this. URLs also get logged, bookmarked, and shared — which is often undesirable.

2. Problems with POST

So many developers started using POST for search:

POST /products/search
Content-Type: application/json

{
  "filters": {
    "category": "electronics",
    "price": { "min": 1000, "max": 50000 },
    "brands": ["samsung", "apple"]
  },
  "sort": "-rating",
  "page": 1,
  "limit": 20
}

But POST is not safe and not idempotent. That means:

Caches and CDNs cannot safely cache the response
Automatic retries after network failures are risky
The server may treat it as a state-changing operation

We have been pretending that a read operation is a write operation for years.

What is the QUERY Method?

According to RFC 10008:

A QUERY requests that the request target process the enclosed content in a safe and idempotent manner and then respond with the result of that processing.

In plain English:

You send the query in the request body (like POST)
The server processes it and returns the result
It does not change any server state (like GET)
Sending the same request multiple times produces the same result (idempotent)

Comparison Table

Property	GET	QUERY	POST
Safe	Yes	Yes	No (potentially)
Idempotent	Yes	Yes	No
Request Body	None	Expected	Expected
Cacheable	Yes	Yes	Limited
URL Length Problem	Yes	No	No
Safe to Auto-Retry	Yes	Yes	No

Examples

Old Way (POST)

POST /feed
Host: example.org
Content-Type: application/x-www-form-urlencoded

q=foo&limit=10&sort=-published

New Way (QUERY)

QUERY /feed
Host: example.org
Content-Type: application/x-www-form-urlencoded

q=foo&limit=10&sort=-published

Or with a JSON body:

QUERY /products/search
Host: api.example.com
Content-Type: application/json
Accept: application/json

{
  "filters": {
    "status": "active",
    "created_after": "2026-01-01",
    "tags": ["security", "web"]
  },
  "sort": ["-created_at"],
  "limit": 50
}

A successful response returns 200 OK with the results.

Important Header: Accept-Query

Servers can now advertise which formats they accept for QUERY:

200 OK
Accept-Query: application/json, application/sql, application/jsonpath
Content-Type: application/json

Examples mentioned in the RFC:

application/json
application/x-www-form-urlencoded
application/sql
application/jsonpath
application/xslt+xml

Why This Matters

Correct Semantics

Read-only operations like search, filtering, and report generation can finally be expressed properly.
Caching & Performance

CDNs, proxies, and browsers can now cache requests that have a body (the body becomes part of the cache key).
Safe Retries

Clients can safely retry after network failures.
Better Privacy & Logging

Complex queries no longer appear in URLs, so they are less likely to be logged.
Better API Design

GraphQL-style queries, JSON filters, SQL-like queries — all can now use a standard HTTP method.

Node.js / Express Example

Most frameworks do not yet support QUERY natively, but it is easy to add:

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

app.use(express.json());

// Custom method support for Express
app.query = function (path, ...handlers) {
  return this.all(path, (req, res, next) => {
    if (req.method === 'QUERY') {
      return handlers[0](req, res, next);
    }
    next();
  });
};

app.query('/search', (req, res) => {
  const filters = req.body;
  // Your search logic here
  const results = searchDatabase(filters);

  res.set('Accept-Query', 'application/json');
  res.json({
    count: results.length,
    data: results
  });
});

app.listen(3000);

Test with curl:

curl -X QUERY http://localhost:3000/search \
  -H "Content-Type: application/json" \
  -d '{"status":"active","limit":10}'

When Should You Use QUERY?

Situation	Recommendation
Simple list + a few filters	GET
Complex filters / nested JSON	QUERY
Search + pagination + sorting	QUERY
Create / Update / Delete data	POST / PUT / PATCH / DELETE
Report generation (read-only)	QUERY

Caveats

Not all browsers, CDNs, WAFs, and load balancers support QUERY yet. Test thoroughly before production use.
QUERY is not currently safelisted for CORS, so a preflight request may be required.
Servers must check the Content-Type. Missing or mismatched Content-Type should return 400 or 415.

Final Thoughts

One of the biggest gaps in HTTP has finally been filled.

The habit of “using POST for search” will slowly fade away.

If you are designing APIs, start considering QUERY for new endpoints. And plan to migrate existing POST-based search endpoints over time.

This article was originally published on my personal blog:

https://rakibulislamdev.me/blog/new-http-query-method-rfc-10008-explained-stop-using-post-for-search

How Frontend Developers Can Easily Deploy a Project on VPS (Beginner Friendly)

Rakibul islam — Sat, 01 Aug 2026 05:25:35 +0000

Many frontend developers think VPS deployment is difficult and only for backend or DevOps engineers.

But the truth is - Frontend developers can easily deploy their own projects on a VPS.

In this article, I’ll show you a simple step-by-step guide to deploy a frontend project (React / Next.js) on a VPS using PM2, Node.js, and GitHub - no advanced backend knowledge required.

We’ll cover both npm and pnpm.

Who is This Guide For?

Frontend Developers
React / Next.js Developers
Beginners who want to deploy without DevOps complexity

Not required: Docker, Nginx, CI/CD

Requirements

Before starting, make sure you have:

A VPS (A2 Hosting, DigitalOcean, AWS, etc.)
VPS IP Address
Username & Password
A frontend project on GitHub
Node.js installed on VPS
npm or pnpm installed
PM2 installed globally

Install PM2

Using npm:

npm install -g pm2

Using pnpm:

pnpm add -g pm2

Step 1: Login to VPS Using Termius

Open Termius (or any terminal) and login to your VPS using:

IP Address
Username
Password

After successful login, you will get terminal access.

Step 2: Go to Project Directory

cd /var/www

/var/www is the standard location for web projects on most VPS.

Step 3: Check Existing Files

ls

Step 4: Clone Project from GitHub (Using SSH)

git clone git@github.com:YourUsername/YourProject.git

Important Notes:

Your GitHub repository must have SSH key set up
VPS SSH key should also be configured

Step 5: Verify Project Folder

ls

You should now see your project folder (for example: my-project).

Step 6: Enter Project Directory

cd my-project

Step 7: Install Dependencies

Using npm:

npm install

Using pnpm:

pnpm install

Step 8: Build the Project

Using npm:

npm run build

Using pnpm:

pnpm build

Step 9: Open Port in VPS Firewall

sudo ufw allow 3000

Step 10: Reload Firewall

sudo ufw reload

Step 11: Start Project Using PM2

Using npm:

pm2 start npm --name "my-project" -- start -- --port 3000

Using pnpm:

pm2 start pnpm --name "my-project" -- start -- --port 3000

Explanation:

my-project → Process name
3000 → Port number (you can change it)

Step 12: Check PM2 Process List

pm2 ls

Step 13: Restart Project (Safe Practice)

pm2 restart my-project

Step 14: Access Live Project in Browser

Open your browser and visit:

http://YOUR_VPS_IP:3000

Congratulations!

Your frontend project is now live on the VPS.

Final Tips

Always use PM2 so that your project keeps running even if you close the terminal.
You can change the port number according to your need.
For custom domain, you can later add Nginx (optional).
Prefer pnpm if you want faster installs and less disk space usage.

If you found this guide helpful, feel free to check out more of my work here:

Portfolio: https://rakibulislamdev.me

Original Article: https://rakibulislamdev.me/blog/how-frontend-developers-can-easily-deploy-a-project-on-vps-beginner-friendly