Developer tasks

Solutions organized by the problem you are solving, not by tool name. Each task links to runnable tools and executable pipelines — every step processes data locally.

Analyze SQL query execution plans 1 tool step · 1 pipeline

EXPLAIN shows how the database executes a query. Learn to read plans, identify bottlenecks, and optimize.

Apply JSON Patch (RFC 6902) operations 2 tool steps

JSON Patch defines a sequence of operations (add, remove, replace, move, copy, test) to modify a JSON document atomically.

Fix common Base64 decoding errors 2 tool steps

Why a Base64 string fails to decode — missing padding, URL-safe alphabets, stray whitespace — and the exact steps to repair each case.

Build and inspect network packets 2 tool steps

Construct raw network packets for testing, debugging, and protocol development. Understand Ethernet, IP, and transport layer encapsulation.

Build URL query strings from objects 2 tool steps · 1 pipeline

Construct properly encoded query strings from JavaScript objects. Handle arrays, nested objects, and special characters correctly.

Calculate business days between dates 2 tool steps

Business day calculation excludes weekends and holidays. Learn to compute working days, add/subtract business days, and handle holidays.

Calculate the difference between two dates 2 tool steps

Find the duration between two dates in days, hours, minutes, or business days, accounting for timezones.

Calculate edit distance (Levenshtein) 2 tool steps

Edit distance measures the minimum number of insertions, deletions, and substitutions to transform one string into another. Used in spell checking and fuzzy matching.

Calculate Levenshtein distance 2 tool steps

Levenshtein distance measures the minimum edits (insert, delete, substitute) to transform one string into another. Used in spell checking and fuzzy matching.

Calculate matrix operations 3 tool steps

Perform matrix addition, multiplication, determinant, inverse, and transpose. Essential for linear algebra, graphics, and ML.

Calculate modular exponentiation efficiently 2 tool steps

Compute base^exponent mod modulus efficiently using the square-and-multiply algorithm. Essential for cryptography.

Calculate subnet masks and wildcard masks 2 tool steps

A subnet mask defines the network/host boundary. Learn to convert between prefix length, dotted-decimal mask, and wildcard mask.

Calculate subnets and address ranges 2 tool steps

Divide a network into subnets using CIDR notation. Calculate network address, broadcast, host range, and available host count.

Calculate TF-IDF for text importance 2 tool steps

TF-IDF (Term Frequency-Inverse Document Frequency) measures word importance in a document relative to a corpus. Used in search and text mining.

Check color contrast for WCAG accessibility compliance 2 tool steps

Measure the contrast ratio between foreground and background colors and verify it meets WCAG AA or AAA thresholds.

Compare block ciphers and stream ciphers 3 tool steps

Block ciphers encrypt fixed-size blocks with padding; stream ciphers encrypt byte-by-byte. Understand the trade-offs in speed, padding, and error propagation.

Compare throughput of different hash algorithms 3 tool steps

Measure how fast SHA-256, SHA-3, BLAKE2/3, and RIPEMD-160 hash a given input to choose the right algorithm for your throughput budget.

Compare two texts and show the differences 1 tool step · 1 pipeline

Diff two versions of a text to see insertions, deletions, and modifications at the line or character level.

Compress and optimize images 3 tool steps

Reduce image file size by choosing the right format (WebP/AVIF), adjusting quality, and resizing. Improve page load speed and Core Web Vitals.

Compress and optimize images for the web 2 tool steps

Reduce image file size by converting format (WebP/AVIF), adjusting quality, and resizing for faster page loads.

Compute cosine similarity between texts 2 tool steps

Cosine similarity measures the angle between text vectors, indicating semantic similarity. Used in search, clustering, and recommendation.

Convert data between Base32, Base58, Base64, Base85, and Base91 3 tool steps

Translate the same binary payload across different base encodings used by different systems (Bitcoin, DNS, PDF, compact serialization).

Convert colors between hex, RGB, HSL, and named formats 2 tool steps

Translate a color value between hex (#ff5733), rgb(), hsl(), and CSS named colors for use in different contexts.

Convert CSS to Sass/SCSS 1 tool step

Sass extends CSS with variables, nesting, mixins, and functions. Convert plain CSS to SCSS to start using these features incrementally.

Convert CSV data to structured JSON 2 tool steps · 1 pipeline

Parse a CSV table (with headers, quoted fields, embedded commas) into an array of JSON objects for programmatic access.

Convert CSV to TSV (tab-separated values) 1 tool step

Change the delimiter from comma to tab. TSV is useful when data contains commas and quoting is undesirable.

Convert CSV to XML 2 tool steps · 1 pipeline

Convert tabular CSV data to XML for systems that require XML input. Each row becomes an XML element with child elements for columns.

Convert CSV to YAML 2 tool steps · 1 pipeline

Convert tabular CSV data to YAML for structured configuration or documentation. Each row becomes a YAML list item with column headers as keys.

Convert .env files to JSON 2 tool steps

.env files store KEY=VALUE pairs for environment configuration. Convert to JSON for structured access, type casting, and validation.

Convert hexadecimal string to Base64 and back 2 tool steps · 1 pipeline

Translate between hex dumps and Base64 representations of the same binary data without losing bytes or introducing padding errors.

Convert HTML to JSX for React 2 tool steps

JSX is HTML with JavaScript expressions. Convert HTML to JSX by closing void tags, converting class to className, and style strings to objects.

Convert HTML to Markdown 2 tool steps · 1 pipeline

Convert HTML content to Markdown for simpler editing, storage, or display in Markdown-aware systems. Handles headings, lists, links, images, and code blocks.

Convert INI configuration files to JSON 2 tool steps

INI files use sections in brackets and key=value pairs. Convert to JSON for programmatic access, validation, and interoperability with modern tools.

Convert between IPv4 and IPv6 address formats 3 tool steps

Convert IP addresses between dotted-decimal, hex, binary, and IPv6 representations. Understand IPv4-mapped IPv6 addresses.

Generate TypeScript interfaces from JSON data 1 tool step · 1 pipeline

Infer TypeScript types from a JSON sample so you can type API responses without hand-writing interfaces.

Convert JSON to YAML and back without losing data 1 tool step · 2 pipelines

Translate between JSON and YAML for config files, preserving nested structures, arrays, and scalar types across the round-trip.

Convert Markdown to HTML 2 tool steps

Render Markdown (headings, lists, code blocks, tables, links) into HTML for display in browsers or email.

Convert between camelCase, snake_case, kebab-case, and PascalCase 2 tool steps · 1 pipeline

Transform identifiers between naming conventions used by different languages and contexts.

Convert Apple plist files to JSON 2 tool steps

Apple property lists (plist) serialize data in XML or binary format. Convert to JSON for cross-platform use and easier manipulation.

Convert Java .properties files to JSON 2 tool steps

Java .properties files use key=value pairs with dot-notation for nesting. Convert to JSON for use in JavaScript environments and structured access.

Convert between Unix timestamp, ISO 8601, and human-readable dates 2 tool steps

Translate a time value between Unix epoch seconds, milliseconds, ISO 8601, and local/UTC date strings.

Convert between timezones correctly 3 tool steps

Timezone conversion is tricky due to DST, abbreviations, and political changes. Learn to use IANA timezone names and the Instant/ZonedDateTime pattern.

Convert TOML configuration to JSON 1 tool step · 1 pipeline

Parse a TOML config file (used by Rust, Python projects) into JSON for tooling that expects JSON input.

Convert XML to JSON and back 2 tool steps · 1 pipeline

Translate between XML and JSON for interoperability with legacy APIs, preserving attributes, namespaces, and mixed content.

Convert XML to YAML 2 tool steps · 1 pipeline

Convert XML documents to YAML for more readable configuration files. YAML's indentation-based syntax is cleaner than XML's tags for human-authored data.

Count words, characters, and analyze text statistics 2 tool steps · 1 pipeline

Get word count, character count, line count, reading time, and frequency analysis for a block of text.

Understand what a cron expression actually runs 2 tool steps

Paste a cron expression, see the exact schedule fields and the next fire times, and learn the notations that most often surprise people.

Debug regex patterns step by step 2 tool steps

Debug regex by testing against sample inputs, visualizing the match, and understanding why a pattern matches or fails. Use flags correctly.

Decode Base64 text and handle missing or corrupted padding 1 tool step · 1 pipeline

Decode Base64 payloads that arrive without trailing '=' padding or with URL-safe alphabet, and recover the original bytes safely.

Read credentials from a Basic Auth header 1 tool step

A Base64 decode, a colon split, and a clear-eyed look at why Basic Auth credentials deserve careful handling.

Read HTML entities in pasted text 1 tool step

Turn & < ' and friends back into real characters — and know when NOT to decode.

Parse a multipart MIME message and extract each part 3 tool steps

Break a multipart/form-data or multipart/mixed MIME message into its constituent headers and bodies for inspection or reprocessing.

Decode a Punycode internationalized domain name to Unicode 3 tool steps

Convert an ACE-encoded domain (xn--...) back to its readable Unicode form, and encode Unicode domains for DNS lookup.

Derive a cryptographic key from a password using a KDF 2 tool steps

Turn a human-memorable password into a fixed-length key suitable for AES or HMAC using PBKDF2, scrypt, or bcrypt with a salt.

Detect the encoding of unknown text and decode it correctly 4 tool steps

Take a string of mojibake or raw bytes, identify whether it is UTF-8, Latin-1, Base64, or URL-encoded, and decode it to readable text.

Detect the language of text 3 tool steps

Language detection identifies the language of a text sample using character n-grams, stop words, and statistical models. Learn common approaches.

Divide a network into smaller subnets (VLSM) 2 tool steps

Variable Length Subnet Masking (VLSM) divides a network into subnets of different sizes, allocating address space efficiently based on need.

Encode binary data into a JSON-safe string 2 tool steps · 1 pipeline

Convert raw bytes (images, encrypted blobs, file contents) into a Base64 string that can be embedded inside a JSON field without breaking the structure.

Encode a file into a Data URI for inline embedding 3 tool steps

Convert a small image, font, or file into a data: URI so it can be embedded directly in HTML, CSS, or Markdown without a separate HTTP request.

Encode special characters for safe insertion into HTML 3 tool steps

Escape <, >, &, ", and ' in user-supplied text so it can be placed inside HTML without triggering XSS or breaking markup.

Encode text for safe use inside a URL query string 2 tool steps · 1 pipeline

Turn arbitrary text (with spaces, ampersands, Unicode, equals signs) into a value that can be placed directly after ?key= in a URL without breaking parsing.

Encode Unicode text into an ASCII-safe representation 2 tool steps

Convert text containing non-ASCII characters (emoji, CJK, accents) into pure-ASCII forms like \uXXXX escapes or HTML entities so it survives ASCII-only channels.

Encrypt text with AES and decrypt it back 2 tool steps

Symmetrically encrypt a message with a passphrase using AES-256-GCM, then decrypt the ciphertext with the same key to recover the original.

Encrypt a large file with AES in chunks 3 tool steps

Encrypt files too large for a single AES operation by processing them in chunks with a streaming mode, then decrypt to recover.

Encrypt data with the Camellia block cipher 2 tool steps

Camellia is a 128-bit block cipher co-developed by Mitsubishi and NTT, certified as a NESSIE and CRYPTREC recommended primitive. Learn its usage and comparison with AES.

Encrypt data with the ChaCha20 stream cipher 2 tool steps

ChaCha20 is a high-speed ARX-based stream cipher designed by Daniel J. Bernstein, used in TLS and as a mobile-friendly alternative to AES.

Encrypt data with the Twofish block cipher 2 tool steps

Twofish is a 128-bit Feistel-network block cipher and AES competition finalist with keys up to 256 bits. Learn the encryption workflow and when to choose it over AES.

Extract all URLs from a block of text 3 tool steps

Find every URL (http, https, ftp) in unstructured text and list them for validation, deduplication, or batch processing.

Extract hashtags from text 2 tool steps

Hashtags start with # followed by letters, numbers, and underscores. Learn to extract, validate, and normalize hashtags from social media text.

Extract @mentions from text 2 tool steps

Mentions start with @ followed by a username. Learn to extract mentions, validate usernames, and link them to user profiles.

Factor integers into primes 2 tool steps

Integer factorization decomposes a number into its prime factors. Learn trial division, Pollard's rho, and why factoring is hard.

Find and replace text using a regular expression 2 tool steps

Search for patterns (not just literal strings) in text and replace matches with a template that can reference capture groups.

Format, validate, and repair malformed JSON 2 tool steps · 1 pipeline

Take a JSON string (possibly minified, with trailing commas, or comments) and produce valid, indented JSON with error diagnostics.

Format and beautify a SQL query 1 tool step · 1 pipeline

Take a minified or poorly-indented SQL query and produce readable, consistently-formatted SQL with keywords uppercased and clauses on separate lines.

Format and beautify SQL statements 1 tool step · 1 pipeline

SQL formatting improves readability and maintainability. Learn indentation rules, keyword alignment, and consistent style for complex queries.

Generate an HMAC and verify a message's authenticity 1 tool step · 1 pipeline

Compute a keyed-hash (HMAC) of a message to prove it came from someone sharing the secret, then verify a received HMAC.

Generate a color palette from a base color 3 tool steps

Derive complementary, analogous, triadic, and shade/tint variants from a single base color for design systems.

Generate cryptographic nonces correctly 2 tool steps

A nonce (number used once) must be unique per encryption under the same key. Learn when to use random vs counter nonces and the consequences of reuse.

Generate a Certificate Signing Request (CSR) 2 tool steps

A CSR contains your public key and identity information, sent to a CA to obtain a signed TLS certificate. Learn the required fields and verification process.

Infer a JSON Schema from sample data 2 tool steps

Generate a JSON Schema that describes the structure of a JSON instance, for validation and documentation.

Generate Lorem Ipsum placeholder text 1 tool step

Produce filler text (paragraphs, sentences, words) for layout prototyping and content placeholders.

Generate NanoIDs for compact unique identifiers 3 tool steps

NanoID is a tiny, URL-safe, unique ID generator. Smaller and faster than UUID, with customizable alphabet and size.

Generate prime numbers 2 tool steps

Generate primes for cryptographic keys and number theory. Learn sieves, primality testing, and safe prime generation.

Generate QR codes for URLs and data 2 tool steps

QR codes encode data in a 2D barcode scannable by cameras. Learn error correction levels, capacity limits, and best practices.

Generate a QR code for a URL 2 tool steps

Create a scannable QR code that encodes a URL, with control over size, error correction, and format.

Generate a cryptographically secure random password 2 tool steps

Create a high-entropy password using a cryptographically secure random generator, with control over length and character sets.

Generate RSA key pair and inspect self-signed certificate fields 2 tool steps

Create an RSA key pair for testing, and understand the structure of a self-signed X.509 certificate for local development.

Generate cryptographically secure session keys 3 tool steps

Session keys must be unpredictable and unique per session. Learn to generate them using a CSPRNG and derive sub-keys with HKDF.

Generate Snowflake IDs for distributed systems 3 tool steps

Snowflake IDs (Twitter) combine timestamp, machine ID, and sequence number for unique, sortable IDs in distributed systems without coordination.

Generate ULIDs for time-sortable identifiers 3 tool steps

ULID (Universally Unique Lexicographically Sortable Identifier) combines a timestamp with random data, producing IDs that sort by creation time.

Handle database deadlocks 2 tool steps

Deadlocks occur when transactions wait on each other's locks. Learn detection, prevention, and retry strategies.

Hash a password and verify it later without storing the plaintext 2 tool steps · 1 pipeline

Use a slow password-hashing function (bcrypt/PBKDF2/scrypt) to store a salted hash, then verify a candidate password against it.

Implement CORS safely 2 tool steps

CORS (Cross-Origin Resource Sharing) allows controlled cross-origin requests. Learn to configure origins, methods, headers, and credentials safely.

Implement Content Security Policy (CSP) 2 tool steps

CSP restricts what resources (scripts, styles, images) a page can load, preventing XSS and data injection. Learn policy directives and reporting.

Implement ECDSA signatures 2 tool steps

ECDSA (Elliptic Curve Digital Signature Algorithm) provides digital signatures with smaller keys than RSA. Learn signing and verification.

Implement end-to-end encryption (E2EE) 3 tool steps

End-to-end encryption ensures only the communicating parties can read messages — no intermediary server holds decryption keys. Learn the hybrid encryption pattern.

Implement HSTS (HTTP Strict Transport Security) 2 tool steps

HSTS forces browsers to always use HTTPS for your site, preventing protocol downgrade attacks and SSL stripping.

Implement mutual TLS (mTLS) authentication 2 tool steps

mTLS requires both client and server to present certificates, providing strong bidirectional authentication without passwords. Common in service-to-service and zero-trust architectures.

Implement perfect forward secrecy (PFS) 2 tool steps

PFS ensures that compromising long-term keys does not reveal past session keys. Learn the ephemeral key exchange pattern that makes this possible.

Implement rate limiting to prevent brute-force attacks 2 tool steps

Rate limiting caps the number of requests per time window, preventing brute-force, credential stuffing, and DoS attacks. Learn token bucket and sliding window algorithms.

Design database indexes for performance 1 tool step

Indexes speed up reads but slow down writes. Learn B-tree, hash, composite, and partial indexes, and when to use each.

Decode and inspect a JWT safely 1 tool step

Paste a JSON Web Token, read its header and claims, and check expiry — while understanding exactly what decoding does and does not prove.

Inspect a JWT token: decode header and payload without verifying 1 tool step · 1 pipeline

Read the structure of a JSON Web Token to see its algorithm, claims, and expiry — purely client-side, no server validation.

Install a TLS certificate on your server 2 tool steps

After receiving a signed certificate from a CA, install it with the correct chain order and verify the deployment with a TLS handshake.

Migrate configuration between JSON and YAML 1 tool step · 2 pipelines

Convert a JSON config to YAML (or back) with a formatted intermediate step, and know the type-coercion pitfalls before you commit the file.

Look up the meaning of an HTTP status code 1 tool step

Get the category, reason phrase, and common usage for any HTTP status code (1xx-5xx).

Look up MAC address vendor (OUI) 1 tool step

The first 3 bytes of a MAC address (OUI) identify the manufacturer. Look up vendors for network device identification and inventory.

Apply JSON Merge Patch (RFC 7396) 2 tool steps

JSON Merge Patch applies a partial JSON object to update a document — null values delete keys, other values replace them. Simpler than JSON Patch.

Minify and beautify CSS 2 tool steps

Compress CSS for production (strip whitespace, comments, merge rules) and beautify minified CSS for debugging.

Normalize a database schema 2 tool steps

Normalization reduces data redundancy and improves integrity. Learn 1NF, 2NF, 3NF, and BCNF with practical examples.

Optimize regex for performance 2 tool steps

Slow regex can cause ReDoS (Regular Expression Denial of Service). Learn to identify and fix catastrophic backtracking, use atomic groups, and anchor patterns.

Optimize slow SQL queries 1 tool step · 1 pipeline

Identify and fix slow SQL queries using EXPLAIN analysis, index optimization, and query rewriting techniques.

Parse a URL into components and construct URLs from parts 3 tool steps

Decompose a URL into protocol, host, path, query, fragment — and build a URL from individual components safely.

Parse a cron expression and explain its schedule in plain English 2 tool steps

Decode a cron expression (e.g. '0 9 * * 1-5') into a human-readable schedule, and generate cron expressions from natural language.

Parse and understand DNS records 2 tool steps

DNS records map domain names to IPs, mail servers, and other data. Learn A, AAAA, CNAME, MX, TXT, NS, and SOA record types.

Parse IPv4 packet headers 2 tool steps

IPv4 headers contain source/destination IPs, TTL, protocol, and fragmentation info. Learn to decode IP headers for packet analysis.

Parse JSON5 — JSON with relaxed syntax 2 tool steps

JSON5 extends JSON with comments, trailing commas, unquoted keys, single quotes, and more. Learn the syntax extensions and conversion to standard JSON.

Parse NDJSON (Newline-Delimited JSON) 2 tool steps

NDJSON stores one JSON object per line, enabling streaming and line-by-line processing. Common in logs, API streaming, and big data pipelines.

Parse OAuth 2.0 token responses 2 tool steps

OAuth 2.0 returns access_token, token_type, expires_in, and optionally refresh_token. Learn to parse and use the token response correctly.

Parse URL query strings 2 tool steps · 1 pipeline

Query strings pass key-value pairs in URLs after the ?. Learn parsing, encoding, and handling of arrays, nested objects, and special characters.

Parse TCP segment headers 2 tool steps

TCP headers contain source/destination ports, sequence numbers, flags, and window size. Learn to decode TCP headers for network analysis.

Parse UDP datagram headers 2 tool steps

UDP headers are 8 bytes: source port, destination port, length, and checksum. Learn to decode UDP for protocol analysis.

Parse XML with namespaces 2 tool steps

XML namespaces qualify element names to avoid collisions. Learn the xmlns declaration, default vs prefixed namespaces, and how to parse them correctly.

Format minified JSON so it can be read (and diffed) 2 tool steps

Turn a one-line API response into indented JSON, with precise error locations when the input is not valid JSON at all.

Prevent clickjacking attacks 2 tool steps

Clickjacking embeds your site in an invisible iframe and tricks users into clicking. Learn X-Frame-Options and CSP frame-ancestors.

Prevent CSRF (Cross-Site Request Forgery) attacks 2 tool steps

CSRF tricks authenticated users into submitting unwanted requests. Learn anti-CSRF tokens, SameSite cookies, and double-submit patterns.

Prevent SQL Injection (SQLi) attacks 2 tool steps

SQLi injects malicious SQL through user input. Learn parameterized queries, input validation, and the principle of least privilege.

Prevent timing attacks on cryptographic operations 2 tool steps

Timing attacks exploit execution time variations to leak secrets. Learn constant-time comparison, uniform processing, and blinding techniques.

Prevent XSS (Cross-Site Scripting) attacks 2 tool steps

XSS injects malicious scripts into web pages. Learn input sanitization, output encoding, and Content Security Policy to prevent XSS.

Remove stop words from text 2 tool steps

Stop words are common words (the, is, at, which) that add little meaning. Removing them improves search and NLP efficiency.

Convert RGB colors to HEX (and back) 2 tool steps

Translate color values between rgb() and #rrggbb notation, with alpha-channel handling for CSS work.

Rotate encryption keys safely 3 tool steps

Key rotation limits the blast radius of a compromised key. Learn the double-encryption migration pattern and how to re-encrypt data without downtime.

Securely wipe sensitive data from memory 2 tool steps

Cryptographic keys and plaintext must be zeroed from memory after use. Learn why memset is not enough and how to prevent compiler optimization.

Sort lines and remove duplicates 1 tool step · 1 pipeline

Take a list of items (one per line), sort them alphabetically or naturally, and remove duplicate lines.

Stem words to their root form 2 tool steps

Stemming reduces words to their stem (running → run, better → bet). Learn Porter stemmer and when to use lemmatization instead.

Store encryption keys securely 3 tool steps

Keys must never be hardcoded or committed to source control. Learn HSM, KMS, envelope encryption, and key derivation patterns for secure key storage.

Stream JSON data for memory-efficient processing 2 tool steps

Streaming JSON parsers process data incrementally without loading the entire document into memory. Essential for large JSON files and real-time APIs.

Test if a number is prime 2 tool steps

Primality testing determines if a number is prime. Learn trial division, Miller-Rabin, and deterministic tests.

Test a regular expression before shipping it 2 tool steps

Validate pattern syntax, inspect every match with capture groups, and learn the backtracking pitfalls that turn a regex into an outage.

Convert a Unix timestamp to a readable date 1 tool step

Turn seconds- or milliseconds-since-epoch values into human dates, and settle the two classic confusions: unit and timezone.

Tokenize text for NLP processing 2 tool steps

Tokenization splits text into tokens (words, sentences, subwords). Learn word, sentence, and subword tokenization for NLP tasks.

Transform text between upper, lower, title, and sentence case 1 tool step · 1 pipeline

Convert text casing for headings, constants, sentences, or display labels.

Decode nested URL-encoded parameters (Base64 JSON in a query string) 1 tool step · 1 pipeline

Unwrap the common API pattern where a URL parameter carries URL-encoded Base64 JSON — one chain, three tools, zero copy-pasting between pages.

Use AES in CTR mode as a stream cipher 2 tool steps

AES-CTR turns the block cipher into a keystream generator, eliminating padding. Learn correct counter management and why you must add authentication separately.

Use AES in GCM mode for authenticated encryption 2 tool steps

AES-GCM provides both confidentiality and integrity in a single operation, detecting tampering without a separate HMAC. It is the recommended AES mode for most applications.

Use HTTP Basic Authentication 2 tool steps · 1 pipeline

Basic Auth sends credentials as Base64-encoded username:password in the Authorization header. Learn the format, security requirements, and alternatives.

Use Bearer tokens for API authentication 2 tool steps · 1 pipeline

Bearer tokens are sent in the Authorization header: "Bearer <token>". Whoever holds the token can access the API — protect it like a password.

Use Bloom filters for set membership 2 tool steps

Bloom filters probabilistically test set membership with no false negatives but possible false positives. Space-efficient for large sets.

Use CBOR encoding for compact binary JSON 2 tool steps

CBOR (Concise Binary Object Representation, RFC 8949) is a binary serialization format for JSON-like data, smaller and faster than JSON.

Use the Chinese Remainder Theorem 2 tool steps

The CRT solves systems of modular congruences. Learn the algorithm and its applications in RSA optimization and secret sharing.

Use CIDR notation for network ranges 2 tool steps

CIDR (Classless Inter-Domain Routing) compactly represents IP ranges. Learn prefix lengths, subnet masks, and how to check if an IP is in a range.

Use consistent hashing for distribution 2 tool steps

Consistent hashing distributes keys across servers with minimal redistribution when servers are added or removed. Used in CDN and distributed caches.

Use constant-time comparison for secret verification 2 tool steps

When comparing secrets (passwords, tokens, MACs), the comparison must take time independent of the values to prevent timing side-channels.

Use cookies securely 2 tool steps

Cookies must be set with Secure, HttpOnly, SameSite, and proper expiration. Learn cookie attributes and security best practices.

Use cron expressions for scheduling 2 tool steps · 1 pipeline

Cron expressions define recurring schedules with 5 fields: minute, hour, day, month, weekday. Learn syntax, special characters, and common patterns.

Use a cryptographically secure pseudorandom number generator 2 tool steps

CSPRNGs produce output indistinguishable from true randomness. Learn the correct APIs and why Math.random() is forbidden in security contexts.

Use Diffie-Hellman key exchange 2 tool steps

Diffie-Hellman allows two parties to establish a shared secret over an insecure channel without ever transmitting the secret itself. The foundation of TLS key exchange.

Use HTTP Digest Authentication 2 tool steps

Digest Auth hashes credentials with a server nonce, preventing password exposure without HTTPS. Learn the challenge-response flow and MD5 usage.

Use ECDH for key exchange 2 tool steps

ECDH (Elliptic Curve Diffie-Hellman) establishes shared secrets using elliptic curves. Smaller keys, same security as DH.

Use elliptic curves for cryptography 2 tool steps

Elliptic curve cryptography (ECC) provides the same security as RSA with much smaller keys. Learn point operations and key exchange.

Use the Extended Euclidean Algorithm 2 tool steps

Extended GCD finds x, y such that ax + by = gcd(a, b). Essential for modular inverses and the Chinese Remainder Theorem.

Use Fast Fourier Transform 2 tool steps

FFT computes the discrete Fourier transform in O(n log n) instead of O(n^2). Used in signal processing, polynomial multiplication, and audio analysis.

Use YAML frontmatter for document metadata 2 tool steps

Frontmatter is YAML metadata at the top of a Markdown file, delimited by ---. Common in static site generators (Astro, Hugo, Jekyll) for page metadata.

Implement full-text search in SQL 2 tool steps

Full-text search indexes words in text for fast searching. Learn to use FULLTEXT indexes, tsvector, and ranking.

Use JSON-LD for linked data and SEO 2 tool steps

JSON-LD (Linked Data) serializes RDF triples in JSON, enabling search engines to understand entity relationships. Used for Schema.org structured data.

Use JSON Pointer (RFC 6901) to reference values 2 tool steps

JSON Pointer defines a string syntax for identifying a specific value in a JSON document using slash-separated path tokens.

Use JWT with RSA signatures (RS256) 2 tool steps · 1 pipeline

RS256 signs JWTs with RSA-SHA256, providing asymmetric verification where only the private key holder can sign but anyone with the public key can verify.

Use Merkle trees for data verification 2 tool steps

Merkle trees hash data into a tree structure, enabling efficient verification of individual elements without downloading the entire dataset.

Use MQTT topic structure for IoT messaging 2 tool steps

MQTT topics use slash-separated hierarchies with wildcards for subscription. Learn topic design, QoS levels, and retained messages.

Use MessagePack for efficient binary serialization 2 tool steps

MessagePack packs JSON-like data into a compact binary format, reducing size and parsing time. Popular in high-performance APIs and IoT.

Enable OCSP stapling for faster TLS handshakes 2 tool steps

OCSP stapling lets the server provide a fresh revocation check to the client during the TLS handshake, avoiding a separate round-trip to the CA.

Use optimistic concurrency control 2 tool steps

Optimistic concurrency assumes conflicts are rare — no locks, just version checking on commit. Learn the version column pattern.

Use regex backreferences 2 tool steps

Backreferences \1, \2, ... match the same text as a previous capturing group. Useful for matching repeated words, paired delimiters, and palindromes.

Use regex character classes effectively 2 tool steps

Character classes [...] match any one character from a set. Learn ranges, negation, shorthand classes, and escaping rules.

Use regex capturing and non-capturing groups 2 tool steps

Groups (...) capture submatches for backreferences and extraction. Non-capturing (?:...) group without capturing. Named groups (?<name>...) improve readability.

Use regex lookahead assertions 2 tool steps

Lookahead (?=...) and (?!...) assert what follows (or doesn't follow) the current position without consuming characters. Zero-width assertions.

Use regex lookbehind assertions 2 tool steps

Lookbehind (?<=...) and (?<!...) assert what precedes the current position. Supported in modern engines (ES2018+, Java, .NET, PCRE).

Use regex quantifiers: *, +, ?, {n,m} 2 tool steps

Quantifiers specify how many times a pattern repeats. Learn greedy, lazy, and possessive matching to avoid catastrophic backtracking.

Use the iframe sandbox attribute 2 tool steps

The sandbox attribute restricts iframe capabilities, preventing malicious embedded content from accessing the parent page.

Use Shamir's Secret Sharing to split keys 2 tool steps

Shamir's Secret Sharing splits a secret into n shares, any k of which can reconstruct it. Useful for key escrow, distributed custody, and eliminating single points of failure.

Use database sharding for horizontal scaling 2 tool steps

Sharding distributes data across multiple databases by a shard key. Learn sharding strategies, cross-shard queries, and trade-offs.

Use CTEs for readable SQL 1 tool step · 1 pipeline

Common Table Expressions (WITH clause) create named temporary result sets, improving readability and enabling recursion.

Use SQL JOIN types correctly 1 tool step · 1 pipeline

INNER, LEFT, RIGHT, FULL, and CROSS joins combine rows from multiple tables. Learn when to use each and how to avoid common pitfalls.

Use SQL subqueries and CTEs 1 tool step · 1 pipeline

Subqueries nest a query inside another. CTEs (WITH clause) provide named, readable subqueries. Learn when to use each.

Use SQL window functions 1 tool step

Window functions (OVER) perform calculations across rows without grouping. Learn ROW_NUMBER, RANK, LAG, LEAD, and aggregate windows.

Understand and use stream ciphers correctly 2 tool steps

Stream ciphers encrypt byte-by-byte using a keystream, offering speed and no padding. Learn correct nonce handling and the fatal mistake of nonce reuse.

Use Subresource Integrity (SRI) for external resources 2 tool steps

SRI ensures external scripts/styles have not been tampered with by verifying their hash. Learn to generate and verify integrity attributes.

Use TOML arrays and array of tables 2 tool steps · 1 pipeline

TOML supports arrays of primitives and arrays of tables. Learn the syntax for inline arrays, multi-line arrays, and [[table]] arrays for structured data.

Use database transactions correctly 1 tool step

Transactions group operations into atomic units — all succeed or all fail. Learn ACID properties and isolation levels.

Understand and configure VLANs 2 tool steps

VLANs logically segment a physical network into isolated broadcast domains. Learn VLAN IDs, tagging (802.1Q), and trunk vs access ports.

Understand WebSocket frame format 2 tool steps

WebSocket frames have a specific binary format with opcode, masking, and payload length. Learn to decode and construct WebSocket frames.

Use XPath to query XML documents 2 tool steps

XPath navigates XML trees with path expressions, predicates, and functions. Learn absolute and relative paths, wildcards, and common functions.

Validate SQL syntax before execution 2 tool steps

Validate SQL queries for syntax errors before sending to the database. Catch typos, missing keywords, and structural issues early.

Validate XML against XSD schema 2 tool steps

XSD (XML Schema Definition) defines the structure, element types, and constraints of an XML document. Validate documents against schemas to ensure correctness.

Verify file or data integrity with a checksum 3 tool steps

Compute a CRC32 or SHA-256 checksum of data and compare it against a known value to detect corruption or tampering.

Verify that encode-decode round-trips losslessly 2 tool steps · 1 pipeline

Confirm that decoding then re-encoding (or vice versa) returns the exact original input, catching silent data corruption from wrong alphabets or padding.

Verify a downloaded file's checksum 2 tool steps

Compute a file's hash locally, compare it with the publisher's checksum, and understand which algorithm to trust.

Write a robust email validation regex 2 tool steps

Email validation regex is notoriously complex due to RFC 5322. Learn practical patterns for common use cases and their limitations.

Write phone number validation regex 2 tool steps

Phone numbers vary wildly by country. Learn practical regex patterns for common formats and why a phone library is often better.

Write a URL validation regex 2 tool steps

URL validation regex must handle protocol, domain, port, path, query, and fragment. Learn practical patterns and when to use a URL parser instead.

Deep dives

Longer references on how these formats and algorithms work.