The network for creativity
Join 1.25M professional creatives like you
Connect with clients, get discovered, and run your business 100% commission-free
Creatives on Contra have earned over $150M and we are just getting started
Back to feedPost
I want to fetch data, I don’t want to change anything, but my query is too complex to fit nicely in a URL.
Before QUERY, developers usually had two choices:
GET — correct for reading data, but complex filters can turn into long, messy URLs.
POST — lets you send structured data in the body, but its semantics don’t clearly express a safe, read-only query.
Now there’s another option:
QUERY /search
{
"filters": {...}
}
QUERY is designed for safe, idempotent requests with a body useful for complex search, analytics, GraphQL, vector search and RAG.
Standardized as RFC 10008 in June 2026. Interesting to see how quickly frameworks and APIs start adopting it.
The network for creativity
Join 1.25M professional creatives like you
Connect with clients, get discovered, and run your business 100% commission-free
Creatives on Contra have earned over $150M and we are just getting started
Related posts
Title: AI Powered Telegram Chatbot
Description: A fully functional Telegram bot powered by Groq AI.
Handles conversations, remembers context and logs all messages
to a Supabase database. Deployed on Railway.
Link: https://t.me/WallexNexus_bot
How do you scope the Supabase conversation memory: per user, per chat, or both? I'd keep private-chat history out of group replies if the bot supports group conversations.
how i ensured seamless user experience with fast api response in really heavy requests and where we should get instant api response: On the gaming boost platform that i have built, the real challenge was implementing complex matrix pricing that works in real time without using websockets ofc
i ensured really fast reponses (RT<3ms) by doing this three steps:
1- First of all understanding client needs and the importance of instant response for optimal user experience.
2- Defining the problem in small steps: in technical side i implemented this on 3 layers
First one is the service layer : the easiest and the light one on size, it fetches the simple content like title, description, FAQs .....
Second Layer : Defining the difference between a service that needs going from point A to point B and this can be done by : linear steps, dropdowns, or slider which accepts 2 values. This is simply can be done via a boolean variable. So a service will only fetch what is on layer 1 + simple boolean variable
Third Layer: This layer will exist only if the boolean is on true, so to go from A to B we should ensure that Last point is > than first point, and we need price from A to B, A to C , B to C and so on...., so the solution was a upper triangular matrix with two parameters (price and required time). So fetching a service that needs this type of pricing will go through those 3 layer, last layer will be fetched depending on the values of 2 body parameters - each api call is dedicated only to get that price and time so very small payload, so each client change will be reflected instantly, but if all the things were implemented in same layer, so loading time will be insane espacially in high traffic.
System Design: Scaling Authentication to 100 Million Users
How would I design a login system for an application with 100 million registered users?
I'd start with the fundamentals: indexed database lookups, connection pooling, rate limiting, secure password hashing, and measurable latency targets.
Then I'd investigate whether a probabilistic data structure could reduce unnecessary database traffic.
The approach: Bloom Filter pre-check
A Bloom Filter can quickly identify usernames that are definitely absent from the registered-user set.
For 100 million entries with a target false-positive rate of 1%:
- Raw bit-array memory: approximately 114 MiB
- Optimal number of hash functions: approximately 7
- False positives: possible
- False negatives: none under correct initialization and maintenance
Proposed request flow
Login Request → Bloom Filter → Indexed User Lookup → Password Verification → Session Issuance
If a username is definitely absent, the system can avoid a database lookup. If it might exist, the request proceeds through the normal authentication process.
Production considerations:
- Maintain filter consistency as users are created or deleted.
- Prevent account enumeration through error messages and timing differences.
- Apply rate limits and abuse detection.
- Benchmark database latency and password-hashing throughput under realistic peak traffic.
- Add caching, replicas, or sharding only when measured bottlenecks justify them.
The key takeaway: 100 million registered users alone does not determine the architecture. Peak login traffic, request distribution, latency requirements, and database capacity do.
A Bloom Filter is an optimization for a specific bottleneck, not a replacement for a properly designed authentication system.
