Guided lessons
Learn developer workflows with Toolzy
Practical, browser-native lessons that start with a realistic broken input, walk through the right tools, and end with a clear diagnosis or cleaned output.
API Debugging
Inspect requests, responses, tokens, URLs, payloads, headers, and scheduler-adjacent API behavior.
Turn a cURL Command Into Client Code
Convert a working command-line request into fetch or Axios code without losing headers or body data.
Inspect Query Params From a Failing URL
Turn a long query string into readable key-value data before debugging an API request.
Inspect a URL Before Debugging a Routing Bug
Break a URL into parts so route, query, and fragment issues are not mixed together.
Data Transformation
Turn messy JSON, CSV, YAML, XML, SQL, query strings, and generated fixtures into shapes a developer can use.
Normalize API Field Names Before Mapping JSON
Turn human column labels into consistent property names before building a payload mapper.
Spot Hidden Reversed Text in a Broken Payload
Reverse a suspicious field to find whether a payload was mirrored, pasted backward, or intentionally obfuscated.
Find Repeated Terms in a Noisy Log or Document
Count repeated words so the real failure theme stands out from noisy text.
Clean a List of IDs Before a Bulk Import
Sort and deduplicate identifiers before a bulk import creates duplicate work.
Inspect and Fix a Messy XML Response
Format XML before deciding whether the response is malformed or merely hard to read.
Read a Dense SQL Query Before Changing It
Format SQL so joins, filters, and limits are reviewable before you edit production data logic.
Find the JSON Syntax Error Breaking a Request
Validate JSON and locate the exact syntax issue before blaming the API.
Make a Nested JSON Response Readable
Pretty-print a dense response so nested fields can be reviewed and copied safely.
Inspect an Unfamiliar JSON Response Before Changing It
Trace paths, arrays, and inconsistent records in an unfamiliar response before changing the code that consumes it.
Turn Messy CSV Into API-Ready JSON
Clean a spreadsheet export into predictable JSON, then inspect the shape before handing it to an API.
Convert a YAML Config Into JSON for an API
Convert configuration data while preserving booleans, arrays, and nested objects.
Generate Types From a Real API Response
Create TypeScript interfaces from actual JSON so client code starts from the real shape.
Validate a Payload Against the Shape You Expect
Use a schema check to separate syntax-valid JSON from contract-valid JSON.
Generate and Check UUIDs for Test Data
Generate UUIDs for fixtures and keep them distinct from meaningful production identifiers.
Generate a Scannable Barcode for a Product Label
Turn a 12-digit GTIN into a print-ready EAN-13 with a computed check digit instead of guessing the thirteenth number.
Compare JSON Payloads Across Environments
Compare a local baseline and a changed payload without confusing ordinary values with structural change.
Find the Record Breaking a JSON Consumer
Use local structure evidence to isolate the record whose shape breaks an otherwise healthy consumer.
Plan a JSON Contract Change
Turn Current and Proposed examples into declared contract intent, local artifacts, and a reviewable rollout plan.
Review Breaking JSON Contract Impact
Review producer, consumer, and rollout consequences without pretending that an inferred sample settles compatibility.
Verify an Implemented JSON Contract
Compare implementation evidence with declared intent so a passing example does not hide an unfinished contract change.
Encoding & Escaping
Handle Base64, URLs, HTML entities, binary text, byte views, and the boundaries between encoding, escaping, hashing, and encryption.
Tell Encoding, Escaping, Hashing, and Encryption Apart
Follow one string through common transformations so you know what can be decoded and what cannot.
Turn a Small Image Into a Data URI
Convert a small image into an embeddable data URI and know when that tradeoff is acceptable.
Fix a URL Parameter That Breaks on Special Characters
Encode query values so spaces, ampersands, and punctuation do not split the URL.
Decode HTML Entities From a Scraped Snippet
Decode entity-heavy text so copied content can be reviewed without losing the original meaning.
Translate Binary Text Into Readable Characters
Decode binary character bytes and confirm the result before using it as text.
Frontend Utilities
Format markup and code, inspect styles, convert UI snippets, and prepare browser-facing assets.
Turn a Draft Title Into a Safe URL Slug
Create a stable slug from editorial text without dragging punctuation into the route.
Review a Config Change Without Missing a Line
Compare two config snippets so a tiny value change does not hide inside whitespace noise.
Build a Regex That Catches the Right Inputs
Test a pattern against matching and non-matching examples before it becomes validation code.
Make Minified HTML Readable Before Debugging
Format dense markup so structure, nesting, and attributes can be reviewed safely.
Clean Up a Snippet Before Reviewing It
Format code before reviewing behavior so style noise does not hide the real issue.
Preview and Fix Markdown Before Publishing
Render Markdown before publishing so broken headings, lists, and links are caught early.
Convert HTML Into JSX Without Breaking Attributes
Convert markup into JSX while preserving semantics and React-friendly attribute names.
Convert Plain Text Into Styled Unicode Safely
Create styled Unicode text while checking whether the result is still appropriate for copy-paste.
Check Fancy Unicode Text Before Pasting It
Preview decorative text before it lands somewhere that cannot render or search it well.
Clean Up Glitched Zalgo Text Before Sharing
Recognize heavy combining marks and keep decorative glitch text away from fragile contexts.
Create Small Unicode Labels Without Breaking Copy-Paste
Use small Unicode text sparingly and keep a normal-text fallback for real labels.
Choose Unicode Styles That Survive Platform Changes
Compare styled text across platform-safe options before using it in public copy.
Security Hygiene
Inspect security-adjacent strings locally: hashes, passwords, JWTs, random tokens, signatures, and certificates.
Generate a Strong Password With the Right Constraints
Generate a password that fits the system policy without weakening it by hand afterward.
Generate Random Tokens for Safe Test Fixtures
Create local-only fixture tokens that look realistic without copying real secrets.
Verify a SHA-256 Hash Before Trusting a File
Generate a digest and compare it carefully instead of relying on a filename or screenshot.
Inspect a JWT From a Failing API Request
Decode a bearer token, read its claims, and check why auth works in one environment but fails in another.
Time, Date & Scheduling
Convert timestamps, read cron expressions, compare time zones, and reduce scheduling ambiguity.
Decode a Cron Schedule Before It Runs
Explain a cron expression in plain language before deploying a scheduled job.
Convert an API Timestamp Before Debugging Time Zones
Convert epoch timestamps before deciding whether a bug is data, timezone, or display logic.
CS Fundamentals
Make low-level concepts visible: number bases, bits, logic, character encodings, and simple classical ciphers.
Convert a Feature Flag Between Binary, Hex, and Decimal
Translate one flag value across number bases and catch where a copied constant changed meaning.
Find the Character That Broke a Copy-Paste Flow
Inspect invisible characters before blaming validation, rendering, or a teammate's paste.
Debug a Bitmask Permission Check
Use fixed-width bitwise operations to explain why one permission bit is missing.
Decode a Negative Integer from Fixed-Width Binary
Decode a two's-complement bit pattern before turning a device value into a fake positive number.
Prove a Conditional Before Shipping It
Generate a truth table to catch a conditional that is correct in prose but wrong in code.
Decode a Morse Message and Check the Spacing
Translate Morse code and verify whether spacing changed letters, words, or the whole message.
Recognize and Decode ROT13 Text
Identify a simple substitution cipher and decode it without mistaking it for encryption.