Sergio Xalambrí

A markup language used to represent structured data in a hierarchical format, historically common in web services before JSON became dominant.

A lightweight data format commonly used in APIs to exchange structured data between clients and servers in a format that is easy for humans to read and machines to parse.

A cryptographic protocol used to secure communications over a network, commonly used by HTTPS and WSS to encrypt data between clients and servers.

A core internet protocol that ensures reliable, ordered delivery of data between devices communicating over a network.

The protocol responsible for addressing and routing packets across networks so data can travel from a source device to a destination device.

A broader identifier used to identify a resource, which may include URLs or other naming schemes that reference resources without specifying their location.

A standardized address used to locate resources on the web, specifying the protocol, domain, path, and optionally query parameters or fragments.

A distributed system that translates human-readable domain names into IP addresses so browsers can locate servers on the internet.

A network protocol used to transfer files between a client and a server, historically common for uploading website files to hosting servers.

A stylesheet language used to control the presentation of HTML documents, including layout, colors, typography, spacing, and responsive design.

The standard markup language used to structure content on the web, defining elements such as headings, paragraphs, links, images, and other page structure.

A secure version of HTTP that encrypts communication between a client and server using TLS, protecting data from interception or modification during transmission.

The application-layer protocol used for communication between web browsers and servers, defining how requests and responses are formatted and transmitted across the web.

The encrypted version of the WebSocket protocol, using TLS to provide secure real-time communication between a client and a server over the internet.

An API exposed over HTTP that allows clients such as browsers or mobile applications to interact with backend services.

Files such as images, fonts, stylesheets, and scripts that are served directly to the browser without server-side processing.

The mechanism that determines which content or component should be displayed based on the current URL, either handled by the server or by client-side routers in SPAs.

The process of generating the UI of an application from data and components, either on the server (SSR) or in the browser (CSR).

A browser technology that allows a server to push real-time updates to the client over a single HTTP connection, commonly used for notifications and live feeds.

A protocol that provides persistent, bidirectional communication between a client and a server, allowing real-time features such as chat, live updates, and streaming data.

A property of an operation where performing the same request multiple times produces the same result, commonly used in APIs to make retries safe.

A distributed network of servers that cache and deliver static assets such as images, scripts, and stylesheets from locations geographically closer to users.

A performance technique where responses or computed data are stored temporarily so future requests can be served faster without repeating the same computation.

A technique used by APIs and servers to restrict how many requests a client can make within a given time period, protecting systems from abuse or overload.

A mechanism where one system sends HTTP requests to another when specific events occur, allowing applications to receive real-time updates without polling an API.

A lightweight JavaScript runtime designed to run code at the edge of a CDN network, commonly used for Edge Functions and SSR close to the user.

A React rendering model where components run on the server and send serialized UI to the client, reducing the amount of JavaScript needed in the browser.

A UX pattern where the interface updates immediately after a user action assuming the server operation will succeed, later reconciling the UI state with the server response.

A web development strategy where a website works with basic functionality using HTML and server responses, and enhances the experience with JavaScript when available.

An extension to the OAuth2 Authorization Code Flow that protects public clients from authorization code interception by requiring a one-time secret during token exchange.

A server that hosts protected resources and validates access tokens before granting access, commonly implemented as an API that trusts tokens issued by an Authorization Server.

A server responsible for authenticating users and issuing tokens such as access tokens and refresh tokens, acting as the central authority in OAuth2 and OpenID Connect systems.

A token used to obtain new access tokens from an Authorization Server without requiring the user to authenticate again, typically long-lived and stored securely by the client.

A credential issued by an Authorization Server that allows a client to access protected resources on a Resource Server, typically short-lived and included in API requests.

A JSON document containing one or more JWKs, typically exposed through a public endpoint so Resource Servers can retrieve the keys required to validate JWT signatures.

A JSON representation of a cryptographic key used in web security systems, commonly published by Authorization Servers so other services can verify signatures on JWTs.

A compact and self-contained token format used to securely transmit claims between parties, commonly used in authentication systems where an Authorization Server issues tokens to clients.

A service that acts as a single entry point for multiple backend services, handling routing, authentication, rate limiting, and request transformation before forwarding requests to internal APIs.

Small serverless functions that run at the edge of a CDN network close to users, often used for authentication, request rewriting, personalization, and lightweight SSR.

A cloud computing model where applications run as short-lived functions managed by a platform, allowing developers to deploy code without managing servers or infrastructure.

An architectural style where an application is composed of multiple independent services that communicate over a network, each responsible for a specific capability and deployable independently.

An application architecture where the frontend, backend, and business logic are developed and deployed together as a single system rather than split across multiple independent services.

An architectural pattern where a backend service is built specifically for a particular frontend, aggregating data from multiple services and shaping responses for that client.

A rendering strategy where SSR runs on edge runtimes located close to users, reducing latency compared to rendering requests in a centralized server or traditional backend.

A variation of SSR where the server sends HTML to the browser in chunks as it is generated, allowing the browser to begin rendering the page before the full response is complete.

An architecture where most of a page is static HTML but small interactive sections, called islands, are hydrated as independent components instead of turning the entire page into a SPA.

A rendering strategy where only specific parts of a server-rendered page are hydrated with JavaScript instead of the entire document, reducing the amount of JavaScript executed in the browser.

The process where client-side JavaScript takes control of HTML generated by SSR, attaching event listeners and restoring application state so the page becomes interactive.

Access React Router's context from any function without passing it through every layer.

https://signalvnoise.com/posts/1430-hire-managers-of-one