<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kaustubh jaiswal on Medium]]></title>
        <description><![CDATA[Stories by Kaustubh jaiswal on Medium]]></description>
        <link>https://medium.com/@kaustubh007j?source=rss-fe41faf91b20------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*bWWMNxOfWqu33Ak0.</url>
            <title>Stories by Kaustubh jaiswal on Medium</title>
            <link>https://medium.com/@kaustubh007j?source=rss-fe41faf91b20------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 20:45:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kaustubh007j/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Meet QUERY: The First New HTTP Verb in 16 Years]]></title>
            <link>https://medium.com/@kaustubh007j/meet-query-the-first-new-http-verb-in-16-years-82092e675634?source=rss-fe41faf91b20------2</link>
            <guid isPermaLink="false">https://medium.com/p/82092e675634</guid>
            <dc:creator><![CDATA[Kaustubh jaiswal]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 18:26:17 GMT</pubDate>
            <atom:updated>2026-07-03T18:26:17.108Z</atom:updated>
            <content:encoded><![CDATA[<p>Why the way we’ve been searching data over the web has always been a little broken — and how a new HTTP method finally fixes it</p><p>If you’ve ever used a website, you’ve used HTTP verbs without knowing it. Every time you load a page, submit a form, or hit “search,” your browser is sending one of a handful of standard instructions to a server: GET, POST, PUT, DELETE, PATCH.</p><p>In June 2026, the list grew for the first time in 16 years. A new method called <strong>QUERY</strong> was formally standardized. It sounds like a small, technical footnote. It’s actually a fix for a problem almost every developer has quietly worked around for two decades.</p><p>Let’s unpack it — first in plain English, then with the technical detail engineers will want.</p><p><strong>The problem, in plain English</strong></p><p>Imagine a library. When you want a specific book, you tell the librarian the title, and they hand it to you. Simple request, simple answer, nothing changes in the library. That’s a bit like <strong>GET</strong> — the web’s way of asking for something without changing anything.</p><p>Now imagine you don’t know the title. You want “mystery novels, published after 2015, available in paperback, sorted by rating.” That’s not a simple lookup anymore — that’s a detailed request. The old way of doing this on the web was to either:</p><ul><li>Stuff all those details into the web address itself (like a search URL that gets absurdly long and messy), or</li><li>Use the “submit a form” method (<strong>POST</strong>), which is meant for <em>changing</em> something — like placing an order — not for <em>asking a question</em>.</li></ul><p>Both options work, technically. But both are the wrong tool. It’s like using a hammer to turn a screw — it’ll eventually get there, but it’s not what the hammer is for, and it causes small problems: web addresses that break when too long, search requests that can’t be safely repeated if something glitches, and answers that never get “remembered” (cached) by the internet’s plumbing because the system thinks something changed when it didn’t.</p><p><strong>QUERY</strong> is the missing tool: a way to ask a detailed question without pretending it’s a form submission.</p><p><strong>The problem, in technical language</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xxumr40vpnKO5OQxbsaLew.png" /></figure><p>HTTP methods aren’t just labels — they carry semantic guarantees that browsers, proxies, CDNs, and API gateways all rely on:</p><ul><li><strong>GET</strong> is <em>safe</em> (no server-side side effects) and <em>idempotent</em> (repeating it changes nothing), and it’s cacheable. But it has no standard mechanism for a request body, so complex query parameters — nested filters, arrays, multi-field sorts — get forced into query strings, hitting URL length limits and readability problems.</li><li><strong>POST</strong> solves the body problem but sacrifices every guarantee GET had. Intermediaries treat POST as state-changing by default, which kills caching and complicates safe retries — a real issue for search-heavy or read-heavy APIs firing off frequent, retryable requests.</li></ul><p>For years, teams have picked one of these two imperfect options depending on which pain they’d rather have. <strong>RFC 10008</strong>, published in June 2026, closes that gap by defining QUERY: a method that keeps GET’s safety and idempotency contract while allowing a structured body, the way POST does.</p><pre>QUERY /articles HTTP/1.1<br>Host: api.example.com<br>Content-Type: application/json<br><br>{<br>  &quot;category&quot;: &quot;technology&quot;,<br>  &quot;publishedAfter&quot;: &quot;2015-01-01&quot;,<br>  &quot;sort&quot;: &quot;rating&quot;,<br>  &quot;page&quot;: 1<br>}</pre><p>Because it’s still safe and idempotent, proxies and CDNs can — in principle — cache responses using the request body as part of the cache key, something POST-as-search never allowed cleanly.</p><p><strong>Who’s using it already</strong></p><p>This isn’t just a paper spec. <strong>.NET 10</strong> already supports QUERY natively — HttpMethod.Query on the client side, and HttpMethods.Query / HttpMethods.IsQuery on the server side. The RFC itself had input from engineers at Cloudflare and Akamai, so CDN-level support is likely to arrive faster than it might for a typical new standard.</p><p>What hasn’t caught up yet: browsers, fetch(), and a lot of general-purpose caching infrastructure. If you&#39;re building a public-facing API today, POST-as-search is still the safe, boring default for now. If you&#39;re building internal, service-to-service APIs — especially in a .NET-based stack — QUERY is usable in production today.</p><p><strong>Why this is worth knowing, even if you never touch a server</strong></p><p>For engineers: this is a genuinely useful primitive for any API with rich, filterable search — the kind of thing that shows up in e-commerce catalogs, admin dashboards, analytics tools, and anywhere users expect to slice data six different ways.</p><p>For everyone else: it’s a small reminder that the invisible plumbing of the internet — the stuff that decides whether your search loads fast, whether a flaky connection can safely retry your request, whether a CDN can serve you a cached answer instead of hammering a database — is still evolving. Sixteen years is a long time for something as fundamental as “how do I ask a detailed question” to go unsolved. QUERY is a quiet but meaningful piece of infrastructure catching up to how complex our data has become.</p><p><strong>The takeaway</strong></p><p>QUERY won’t replace GET or POST — it fills a gap they left behind. It’s the “detailed question” verb the web never quite had: safe, repeatable, and able to carry real complexity in the request. Early, but real, adoption is already happening in places like .NET 10, and CDN support may follow sooner than usual thanks to direct industry involvement in the standard.</p><p>If you design or consume APIs with rich search or filtering, it’s worth keeping on your radar — not as a fad, but as a long-overdue fix finally arriving.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XbAePXedPJr-IDEF5z1C6A.png" /></figure><p>— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —</p><p><em>Are you likely to adopt QUERY once tooling catches up, or will POST-as-search remain the pragmatic default in your stack for a while yet? Curious how other engineers are thinking about this.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82092e675634" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[In the world of web development and real-time communication, there are several methods for handling…]]></title>
            <link>https://medium.com/@kaustubh007j/in-the-world-of-web-development-and-real-time-communication-there-are-several-methods-for-handling-ca2ad74262c4?source=rss-fe41faf91b20------2</link>
            <guid isPermaLink="false">https://medium.com/p/ca2ad74262c4</guid>
            <dc:creator><![CDATA[Kaustubh jaiswal]]></dc:creator>
            <pubDate>Thu, 09 Nov 2023 16:26:03 GMT</pubDate>
            <atom:updated>2023-11-09T16:26:03.568Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/664/1*8L_KCxKCPZz0CC62OIle_A.png" /></figure><blockquote><strong>When to Use Webhooks, WebSockets, Pub/Sub, and Polling</strong></blockquote><p>In the world of web development and real-time communication, there are several methods for handling data and events between clients and servers. Four common approaches are Webhooks, WebSockets, Pub/Sub (Publish/Subscribe), and Polling. Each of these methods serves specific use cases and has its own advantages and disadvantages. In this blog, we will explore when to use each of these techniques and provide examples for better understanding.</p><blockquote><strong>What are Webhooks:</strong></blockquote><p>Webhooks are HTTP callbacks used to notify external system about specific events.</p><p>They allow servers to push data to clients when specific events occur.</p><p>Webhooks are best suited for scenarios where you want to notify clients about changes as they happen, such as updates, new data, or events.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/947/1*ID9qyLPmVDu2hirUC7fiWQ.png" /></figure><blockquote><strong>When to use Webhooks:</strong></blockquote><ul><li>Real-time one-way communication (from source to destination).</li><li>A non-persistent connection between the two systems’ communication.</li><li>You want to respond immediately to an event from a SaaS application that supports webhooks.</li><li>You want to use the push model to immediately push updates.</li><li>The communication is one-to-one</li></ul><p>Examples:</p><ol><li>An e-commerce store notifying your invoicing application about a sale.</li><li>Monitoring systems alerting administrators about an error or unusual activity in a system.</li><li>Payment gateway notifying merchants about a payment.</li></ol><blockquote><strong>What are WebSockets:</strong></blockquote><p>WebSocket is a full-duplex communication protocol that establishes a persistent, bidirectional connection between a client and a server. It’s designed for low-latency, interactive, and real-time communication, making it ideal for applications requiring constant updates and user interactions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*Gdp9zHsv1IAPyTHp1NYlHA.png" /></figure><p><strong>Differences between webhooks and WebSockets:</strong></p><ul><li><strong>Purpose:</strong></li></ul><p><strong>Webhooks</strong>: Webhooks are typically used for one-way communication, where a server or application sends data to another server or application when a specific event or trigger occurs. They are commonly used for event notifications, data synchronization, and integrating third-party services.</p><p><strong>WebSockets</strong>: WebSockets are designed for bidirectional, full-duplex communication, allowing both the client and server to send data to each other in real-time. They are well-suited for chat applications, online gaming, collaborative tools, and any use case that requires low-latency, interactive communication.</p><ul><li><strong>Connection Type:</strong></li></ul><p><strong>Webhooks</strong>: Webhooks rely on HTTP(S) requests. When an event occurs, the server sends an HTTP request to a predefined URL (usually provided by the recipient) with relevant data in the request body. It’s essentially a request- response mechanism, and the recipient doesn’t initiate the connection.</p><p><strong>WebSockets</strong>: WebSockets establish a persistent connection between the client and server, enabling continuous and low-latency data exchange without the need for repeated HTTP requests. The connection is initiated by the client, and both the client and server can send messages independently.</p><ul><li><strong>Scalability:</strong></li></ul><p><strong>Webhooks</strong>: Webhooks can lead to scalability challenges for the recipient, especially when dealing with a large number of events. Each event triggers an HTTP request, which can result in many incoming requests to handle.</p><p><strong>WebSockets</strong>: WebSockets are more scalable because they maintain a single, long-lived connection. This reduces the overhead associated with opening and closing connections for every event, making them more suitable for high-frequency and real-time applications.</p><ul><li><strong>Latency:</strong></li></ul><p><strong>Webhooks</strong>: Webhooks may introduce some latency, as the recipient needs to wait for the sender to trigger the event and send an HTTP request.</p><p><strong>WebSockets</strong>: WebSockets offer low-latency communication, as the connection is always open, and data can be sent immediately when it’s available, without the need to establish a new connection for each message.</p><ul><li><strong>Supported Use Cases:</strong></li></ul><p><strong>Webhooks</strong>: Webhooks are suitable for scenarios where you need to react to specific events or notifications, but immediate real-time interaction isn’t necessary. Examples include receiving notifications from third-party services or updating a system when certain data changes.</p><p><strong>WebSockets</strong>: WebSockets are ideal for applications that require real-time updates, such as chat applications, online gaming, collaborative document editing, and live data feeds.</p><blockquote><strong>When to use WebSockets:</strong></blockquote><p>Webhooks are better for one-way event notifications and integrations, while WebSockets are designed for real-time, bidirectional communication.</p><blockquote><strong>What are pub/sub</strong></blockquote><p>Pub/Sub is a messaging pattern where publishers send messages to a topic, and subscribers receive those messages from the topic they’re interested in. It’s suitable for scenarios where multiple clients or services need to be notified of specific events or data changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/921/1*hqt5WXOd9lliDa4ikV_90w.png" /></figure><p><strong>Differences between webhooks and pub/sub:</strong></p><ul><li><strong>Purpose</strong>:</li></ul><p><strong>Webhooks</strong>: Webhooks are a way for one system to send real-time data to another system as soon as a specific event or trigger occurs. Webhooks are typically used to notify a recipient system about a specific event or update, such as a new order in an e-commerce platform or a code deployment in a version control system.</p><p><strong>Pub/Sub</strong>: Pub/Sub is a messaging pattern that allows multiple subscribers to receive messages or events from one or more publishers. It is used for broadcasting messages to multiple subscribers who have expressed interest in receiving those messages. Pub/Sub systems are often used in scenarios like chat applications, stock market data distribution, or IoT device.</p><ul><li><strong>Communication Flow</strong>:</li></ul><p><strong>Webhooks</strong>: In a webhook-based system, the sender (the source of the event) pushes data to the receiver (the destination) in real-time. The receiver provides a specific URL (endpoint) for the sender to make HTTP requests when an event occurs.</p><p><strong>Pub/Sub</strong>: In a Pub/Sub system, publishers send messages to a central topic or channel without knowing who the subscribers are. Subscribers express their interest in specific topics or channels and receive messages from those topics when published. The communication is decoupled, meaning publishers and subscribers don’t need to be aware of each other.</p><ul><li><strong>Subscription Model:</strong></li></ul><p><strong>Webhooks</strong>: Webhooks have a one-to-one relationship, meaning each webhook is typically associated with a specific event or resource. When the event occurs, the webhook is triggered, and the data is sent to the preconfigured URL.</p><p><strong>Pub/Sub</strong>: Pub/Sub has a one-to-many relationship, where multiple subscribers can listen to the same topic or channel. When a publisher sends a message to a topic, all interested subscribers receive a copy of the message.</p><ul><li><strong>Acknowledgment</strong>:</li></ul><p><strong>Webhooks</strong>: Webhooks do not require acknowledgment. The sender makes a POST request to the recipient’s endpoint, and the recipient processes the data. If there is an error or failure, the sender might not be aware of it unless error handling is implemented.</p><p><strong>Pub/Sub</strong>: Pub/Sub systems often include acknowledgment mechanisms. Subscribers typically confirm receipt of messages, and publishers can re- send messages if acknowledgments are not received. This ensures more reliable message delivery.</p><ul><li><strong>Scaling:</strong></li></ul><p><strong>Webhooks</strong>: Webhooks can put more load on the recipient system, as each webhook trigger initiates an HTTP request. Scalability and load management must be carefully considered.</p><p><strong>Pub/Sub</strong>: Pub/Sub systems are designed for high scalability, as they can handle a large number of publishers and subscribers efficiently. Message distribution is typically handled by the Pub/Sub service, allowing for better load distribution.</p><p><strong>When to use Pub/Sub:</strong></p><p>Webhooks are best suited for one-to-one event notification scenarios, while Pub/Sub is ideal for one-to-many message distribution (works asynchronously).</p><blockquote><strong>What are Polling:</strong></blockquote><p>Polling involves regularly checking for updates or changes by making periodic requests to a server. While it’s a simple approach, it may not be the most efficient method for real-time communication and should be used when instant updates are not required<strong>.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/994/1*lvpWz9jo2mLF4SWTWbcBJQ.png" /></figure><p><strong>Differences between webhooks and Polling:</strong></p><ul><li><strong>Webhooks:</strong></li></ul><p><strong>Push mechanism</strong>: Webhooks use a push approach. When an event occurs in the source system, it immediately sends a notification or payload to the destination system, typically via an HTTP POST request.</p><p><strong>Event-driven</strong>: Webhooks are ideal for event-driven architectures, where the destination system only receives data when something specific happens.</p><p><strong>Efficient</strong>: Webhooks are more efficient for real-time updates because they eliminate the need for continuous polling, reducing network and server load.</p><p><strong>Faster response</strong>: Webhooks provide near-instantaneous notifications to the destination system, making them suitable for applications that require quick reactions to events.</p><p>Example use case: A chat application that sends a webhook notification to update a user’s chat interface in real-time when a new message is received.</p><ul><li><strong>Polling:</strong></li></ul><p><strong>Pull mechanism</strong>: Polling uses a pull approach, where the destination system regularly queries the source system at fixed intervals (e.g., every few seconds) to check for updates.</p><p><strong>Polling interval</strong>: Polling can be resource-intensive because it requires frequent requests, even when there are no new updates. The polling interval must be chosen carefully to balance timely updates and resource efficiency.</p><p><strong>Delayed response</strong>: Polling introduces a delay in receiving updates because the destination system has to wait for the next polling cycle to retrieve new data.</p><p><strong>Suitable for slower-changing data</strong>: Polling is suitable for scenarios where updates are less frequent and immediate responses are not critical.</p><p>Example use case: An email client checking for new emails every few minutes by periodically polling the email server.</p><blockquote><strong>When to use Polling:</strong></blockquote><p>Webhooks are more efficient and suitable for real-time event-driven applications, providing immediate updates when events occur. On the other hand, polling is a pull-based approach that may introduce delays, making it more suitable for scenarios where immediate updates are not required or when the source system doesn’t support webhooks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca2ad74262c4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>