Guides & tools

Play

• How to play Solana dice Step-by-step tutorial — free demo, wallet or Solana Pay, verify on-chain, share challenges.
• Play Garden Dice — Solana dice game Free demo and pay from 0.001 SOL — player-focused product page with inline roll.
• Play Solana dice online Browser dice on mainnet — no download, free demo, pay from 0.001 SOL on desktop or mobile.
• Provably fair Solana games Commit-reveal fairness you can verify — free demo, then pay from 0.001 SOL on mainnet.
• Wallet-native Solana games Browser games that pay from your wallet — no app download, free demo, micropayments from 0.001 SOL.
• On-chain Solana games in your browser Wallet-native play on mainnet — free demo, micropayments from 0.001 SOL, verifiable results.
• Free Solana games in your browser Try Garden Dice with a free demo roll — no wallet required — then pay from 0.001 SOL.
• Best Solana wallets for browser games Compare Phantom, Solflare, and Backpack for Garden Dice — free demo, connect, or Solana Pay from 0.001 SOL.
• Play Solana games with Phantom wallet Installed Phantom? Try Garden Dice — free demo, desktop connect, or Solana Pay QR from 0.001 SOL.
• Play Solana games with Solflare wallet Installed Solflare? Try Garden Dice — free demo, desktop connect, or Solana Pay QR from 0.001 SOL.
• Play Solana games with Backpack wallet Installed Backpack? Try Garden Dice — free demo, desktop connect, or Solana Pay QR from 0.001 SOL.
• Solana games hub Wallet-native games on Solana Garden.

Guides

• Solana wallet tutorial — full path Four steps from installing Phantom to your first 0.001 SOL micropayment on Garden Dice.
• Build log: wallet-native dice Technical write-up — RPC proxy, Solana Pay QR, commit-reveal, challenge pages.
• Provably fair dice on Solana Commit-reveal fairness, inline demo, and pay without leaving the page.
• Your first Solana payment Step-by-step first mainnet transfer — fund a wallet, approve 0.001 SOL, verify on Solscan.
• Solana transaction fees explained Base fee (~5,000 lamports), priority fees, and total cost of a 0.001 SOL micropayment.
• Set up Phantom wallet for Solana Install, secure your recovery phrase, fund mainnet — start here if you are new.
• Set up Solflare wallet for Solana Install Solflare, secure your recovery phrase, fund mainnet — second-wallet onboarding path.
• Set up Backpack wallet for Solana Install Backpack extension or mobile app, fund mainnet — third-wallet path supported on Garden Dice.
• Solana wallet security best practices Protect your seed phrase, spot phishing drains, use hot vs cold wallets, and sign transactions safely on mainnet.
• Multisig wallets explained: threshold signatures, DAO treasuries and safe custody m-of-n threshold design, Bitcoin P2WSH and PSBT flows, Ethereum Safe and Solana Squads vaults, signer hygiene, quorum loss traps, MPC vs on-chain multisig, and a treasury checklist.
• Solana token approvals explained SPL delegate authority, how it differs from Ethereum allowances, red flags in wallet popups, and how to revoke stale approvals.
• How to get SOL on Solana Fund mainnet — buy, exchange withdraw, or receive. Pick Phantom, Solflare, or Backpack, then practice a 0.001 SOL roll.
• Solana wallet cleanup — hide spam and reclaim rent Declutter your wallet on mainnet — hide scam airdrops, close empty accounts, recover SOL — then try a 0.001 SOL roll.
• Reclaim Solana rent — close empty token accounts Recover ~0.002 SOL per empty SPL account in Phantom, Solflare, or Backpack — then try a 0.001 SOL roll.
• Solana spam tokens — hide and burn scam airdrops Hide unknown tokens, avoid phishing links, close empty accounts — then try a 0.001 SOL roll.
• Get SOL in Phantom wallet Buy in-app, withdraw from an exchange, or receive SOL — then practice a 0.001 SOL roll.
• Get SOL in Solflare wallet Buy in-app, withdraw from an exchange, or receive SOL in Solflare — then practice a 0.001 SOL roll.
• Get SOL in Backpack wallet Buy in-app, withdraw from an exchange, or receive SOL in Backpack — then practice a 0.001 SOL roll.
• Fix Phantom insufficient SOL error Payment plus network fee must fit in your balance — how much to add and retry.
• Switch Phantom to mainnet Fix wrong network — Devnet SOL cannot pay live sites; select Mainnet Beta and retry.
• Switch Solflare to mainnet Fix wrong network in Solflare — Devnet SOL cannot pay live sites; select Mainnet Beta and retry.
• Switch Backpack to mainnet Fix wrong network in Backpack — Devnet SOL cannot pay live sites; select Mainnet Beta and retry.
• Fix Backpack insufficient SOL error Payment plus network fee must fit in your Backpack balance — how much to add and retry.
• Fix Solflare insufficient SOL error Payment plus network fee must fit in your Solflare balance — how much to add and retry.
• Solana devnet vs mainnet explained Test SOL vs real SOL — when to use devnet, faucets, RPC endpoints, and avoiding wrong-network payments.
• Solana wrong network — switch to mainnet Devnet or Testnet balance? Pick Phantom, Solflare, or Backpack — switch to Mainnet Beta, then retry pay.
• Solana transaction failed — fix by wallet Generic payment failure? Pick Phantom, Solflare, or Backpack — symptom table plus inline retry roll.
• Solana insufficient SOL — fix by wallet Not enough SOL for payment plus fee? Pick Phantom, Solflare, or Backpack — balance table plus inline retry roll.
• Fix Phantom transaction failed Cancelled, insufficient SOL, wrong network, blocked popup, or site did not detect payment — diagnose and retry.
• Fix Solflare transaction failed Cancelled, insufficient SOL, wrong network, blocked popup, or site did not detect payment in Solflare — diagnose and retry.
• Fix Backpack transaction failed Cancelled, insufficient SOL, wrong network, blocked popup, or site did not detect payment in Backpack — diagnose and retry.
• Connect a Solana wallet to a dApp Wallet connect on mainnet — pick Phantom, Solflare, or Backpack, approve safely, then practice a 0.001 SOL roll.
• Connect Phantom to a Solana site Wallet connect walkthrough — approve safely, then try a 0.001 SOL micropayment.
• Connect Solflare to a Solana site Solflare wallet connect walkthrough — approve safely, then try a 0.001 SOL micropayment.
• Connect Backpack to a Solana site Backpack wallet connect walkthrough — approve safely, then try a 0.001 SOL micropayment.
• How to send SOL on Solana Transfer on mainnet — recipient, amount, fees. Pick Phantom, Solflare, or Backpack, then practice a 0.001 SOL roll.
• Send SOL with Phantom Wallet transfer walkthrough — then try a 0.001 SOL micropayment on Garden Dice.
• Send SOL with Solflare Solflare transfer walkthrough — then try a 0.001 SOL micropayment on Garden Dice.
• Send SOL with Backpack Backpack transfer walkthrough — then try a 0.001 SOL micropayment on Garden Dice.
• Solana micropayments — pay from 0.001 SOL Wallet and Solana Pay QR micropayments on mainnet — live practice roll on Garden Dice.
• Accept Solana payments on your website Merchant guide — Solana Pay URLs, QR checkout, on-chain verification, live 0.001 SOL demo.
• Solana Pay QR generator Free transfer URL + QR builder; scan from Phantom or Solflare, verify on-chain.
• Fix Solana Pay not working QR won't scan, wrong amount, or paid but site did not detect — mobile and detection fixes.
• Solana Token-2022 extensions explained Transfer fees, metadata pointers, transfer hooks, interest-bearing tokens, and how Token-2022 mints differ from classic SPL.
• Solana Metaplex NFT standards explained Token Metadata PDAs, master and print editions, verified collections, creator royalties, Candy Machine mints, compressed NFTs, and Metaplex vs Token-2022 metadata.
• Solana SPL token accounts explained Associated token accounts (ATAs), rent deposits, and why your wallet holds more on-chain addresses than you expect.
• Solana priority fees explained Compute units, micro-lamports per CU, when you need a priority tip, and fixing dropped transactions.
• Solana compute units explained: limits, budgeting and program optimization How the BPF runtime meters execution — default 200k limits, setComputeUnitLimit and setComputeUnitPrice, simulation logs, CPI overhead, and optimization patterns.
• Solana MEV explained Maximal extractable value — sandwich attacks, DEX arbitrage, Jito bundles, block engines, and how to protect your swaps.
• Solana RPC endpoints explained Public vs dedicated RPC, mainnet and devnet URLs, rate limits and 429 errors, and how wallets and backends stay reliable.
• Solana Anchor framework explained: accounts, instructions and IDL Rust macros for Solana programs — account constraints, PDAs, CPI helpers, IDL generation, testing workflows, and Anchor vs native trade-offs.
• How to deploy a Solana program CLI and Anchor deployment — program keypairs, BPF loader, upgrade authority, and devnet-to-mainnet steps.
• Solana transaction simulation explained Dry-run transactions before signing — simulateTransaction RPC, wallet preflight, program logs, and common failure causes.
• Solana account model explained Accounts, owners, lamports, rent-exempt minimums, PDAs, and why your wallet holds more on-chain addresses than you expect.
• Solana versioned transactions & lookup tables v0 wire format, address lookup tables (ALTs), transaction size limits, and when complex swaps need compressed account lists.
• Solana cross-program invocation (CPI) explained How programs call other programs — invoke vs invoke_signed, PDA signing, account permissions, and atomic composability.
• Solana program derived addresses (PDAs) explained Seeds, bumps, findProgramAddress, invoke_signed signing, vault and escrow patterns, and why programs need addresses without private keys.
• Solana blockhash and transaction expiry explained Why every tx needs a recent blockhash, the ~150-slot expiry window, blockhash not found errors, and how wallets refresh stale transactions.
• Solana durable nonce accounts explained: offline signing and long-lived transactions When and how to use durable nonce accounts instead of recent blockhashes — advanceNonce ordering, nonce authority, multisig treasuries, nonce pools, and security pitfalls.
• Solana slots and epochs explained How Solana measures on-chain time — ~400 ms slots, ~2-day epochs, slot leaders, Proof of History, and processed vs finalized commitment.
• Solana consensus explained: Proof of History, Tower BFT and finality How validators agree at high speed — PoH ordering, stake-weighted Tower BFT lockouts, confirmation levels, fork choice, and what processed vs finalized means for payments.
• Solana staking explained Proof-of-stake delegation, validator rewards per epoch, commission fees, liquid staking tokens, and risks beyond quoted APY.
• Beat my roll — challenge links Viral challenge URLs with roll-specific OG previews and inline pay.
• Read a Solana transaction on Solscan Decode status, amounts, addresses, and fees on the most popular Solana block explorer.
• How long do Solana transactions take? Processed vs finalized, typical wait times, RPC lag, and what to do when a payment seems stuck.
• Verify a Solana payment Confirm a SOL transfer landed — inline tx lookup after Solana Pay or wallet sends.

Markets & macro

• Stock market fundamentals explained What shares represent, market cap, P/E and earnings, dividends, major indices, bull and bear markets, and how equities fit in a diversified portfolio.
• Fundamental analysis explained: earnings, valuation and moats Financial statements, P/E and FCF yield, discounted cash flow intuition, qualitative moats, crypto tokenomics, and pairing fundamentals with technical timing.
• Financial statements explained: balance sheet, income statement and cash flow Read the three core SEC filings — revenue to net income, assets and liabilities, operating/investing/financing cash flows, free cash flow, statement links, red flags, and a retail checklist.
• P/E ratio and valuation multiples explained: price-to-earnings, PEG and EV/EBITDA Trailing vs forward P/E, what drives multiples, PEG and EV/EBITDA triangulation, sector norms, cyclical traps, negative earnings, and a retail checklist for comparing stocks without overpaying.
• Earnings reports explained: EPS beats, guidance and earnings season Quarterly 10-Q and 10-K filings, consensus surprises, forward guidance vs headline beats, earnings calls, after-hours gaps, options vol crush, and a retail checklist.
• IPO investing explained: S-1 filings, lockups, retail access and valuation How initial public offerings work — primary vs secondary markets, roadshow pricing, first-day pops, lockup cliffs, broker allocation limits, S-1 due diligence, and why patience beats chasing openings.
• Value investing explained: margin of safety, quality and value traps Graham and Buffett principles, intrinsic value, quality vs deep value, screening metrics, value traps, factor cycles, passive value ETFs, and a patient-equity checklist.
• Growth investing explained: revenue growth, PEG ratio and quality growth Revenue and earnings acceleration, PEG and Rule of 40, TAM sizing, growth vs value cycles, quality vs hype, growth traps, and sizing growth tilts in a diversified portfolio.
• Momentum investing explained: trend following, relative strength and factor risk Price momentum vs growth and value — 12-1 month relative strength, time-series trend rules, momentum crashes, ETF implementation, crypto trend overlays, and sizing factor tilts.
• Factor investing explained: smart beta, multi-factor portfolios and factor cycles Value, momentum, size, quality and low-volatility premiums — Fama-French foundations, smart beta ETF rules, factor timing traps, overlap audits, and core-satellite sizing.
• Sector rotation investing explained: business cycles, cyclicals and defensives GICS sectors and macro regimes — early recovery vs late-cycle leadership, cyclical vs defensive splits, sector ETF tools, relative-strength rules, timing pitfalls, and core-satellite sizing.
• Bitcoin fundamentals explained Proof-of-work mining, the 21 million supply cap, halving cycles, wallet custody, spot ETFs, volatility, and how BTC fits in a diversified portfolio.
• Ethereum fundamentals explained Account model, smart contracts and the EVM, gas and EIP-1559 burn, proof-of-stake staking, Layer 2 rollups, custody, ETFs, and sizing ETH in a portfolio.
• Proof of stake explained: validators, staking, slashing and security PoS vs proof-of-work, validator selection and delegation, slashing economics, Ethereum and Solana variants, liquid staking tradeoffs, long-range attack mitigations, and a retail staking checklist.
• Tokenomics explained: supply, vesting, value accrual and evaluation Fixed vs inflationary supply, emission schedules and vesting cliffs, utility vs governance tokens, fee burn and staking accrual, FDV traps, unlock calendars, on-chain holder metrics, and a pre-buy checklist.
• Cross-chain bridges explained: security, wrapped assets and bridge risks Lock-and-mint vs liquidity networks, validator multisigs and ZK proofs, wrapped token mechanics, famous exploit patterns, bridges vs L2 rollups, and a due-diligence checklist before you move assets across chains.
• Layer 2 blockchains and scaling explained: rollups, bridges and security Optimistic vs ZK rollups, data availability and EIP-4844 blobs, canonical bridges vs fast liquidity, sequencer centralization, major L2 ecosystems, and an evaluation checklist before you deposit.
• Zero-knowledge proofs explained: ZK-SNARKs, STARKs and blockchain scaling Prove statements without revealing private data — interactive vs non-interactive proofs, SNARK trusted setup vs transparent STARKs, ZK rollups and privacy use cases, data availability pairing, and an evaluation checklist.
• Smart contracts explained: EVM, Solana programs, risks and use cases Self-executing blockchain code — deployment and immutability, proxy upgrades, DeFi and NFT use cases, reentrancy and oracle exploits, gas economics, and due diligence before you connect a wallet.
• Blockchain oracles explained: price feeds, Chainlink, Pyth and DeFi risks Push vs pull feeds, decentralized oracle networks, spot manipulation and stale-price exploits, TWAP and circuit breakers, Solana Pyth/Switchboard, and a due-diligence checklist.
• Bonds and fixed income explained Coupon vs yield, duration and interest rate risk, Treasury and corporate debt, bond funds vs individual bonds, and sizing fixed income in a 60/40 portfolio.
• Bond ladder investing explained: rungs, reinvestment and rate risk Staggered maturities for predictable principal — T-bill vs coupon ladders, reinvestment when rates shift, callable traps, tax placement, ladder vs bond funds, and a retail checklist.
• Treasury bills (T-bills) explained: auctions, yields and cash allocation Short U.S. government debt — discount pricing, weekly auctions, laddering maturities, T-bills vs savings and money market funds, state tax exemption, ETF wrappers, and sizing a cash sleeve.
• Emergency fund explained: how much to save, where to park it and when to use it The financial shock absorber every portfolio needs — 3-to-6-month sizing, HYSA vs money market vs T-bill ladders, building while paying debt, sinking-fund separation, and a production checklist.
• Mortgages explained: rates, down payments, PMI and the homebuyer checklist How home loans work — fixed vs ARM, 15- vs 30-year terms, PITI payment math, down payment and PMI rules, pre-approval, DTI limits, closing costs, points, and when buying beats renting.
• Money market funds explained: yields, NAV stability, sweep accounts and cash parking Government vs prime vs municipal MMFs, stable $1 NAV and breaking the buck, brokerage sweep accounts, SEC seven-day yield, MMF vs HYSA vs T-bills, tax treatment, and a retail cash-allocation checklist.
• Annuities explained: fixed, variable, SPIA and retirement income Insurance contracts that convert savings into paychecks — fixed vs variable vs indexed, immediate SPIA vs deferred longevity annuities, fees and surrender charges, tax treatment, inflation risk, and when guaranteed income beats portfolio withdrawals.
• Credit scores explained: FICO, VantageScore, factors and how to improve How lenders grade borrowing history — payment history and utilization math, hard vs soft inquiries, thin-file building, dispute workflows, common myths, and a pre-mortgage checklist.
• Compound interest explained: growth, Rule of 72 and real returns How returns earn returns — simple vs compound growth, the Rule of 72, compounding frequency, inflation-adjusted real returns, debt traps, early-starter math, and a savings checklist.
• Retirement accounts explained: 401(k), Roth IRA, Traditional IRA and rollovers Tax-advantaged saving — employer 401(k) matching, Roth vs Traditional tax treatment, contribution limits, job-change rollovers, withdrawal penalties, RMDs, and a savings priority checklist.
• 529 plans explained: college savings, tax benefits and FAFSA rules Tax-free growth for education — prepaid vs savings plans, qualified expenses, state deductions, superfunding, financial aid treatment, SECURE 2.0 Roth rollovers, and a family planning checklist.
• Required minimum distributions (RMD) explained: age, calculation and tax planning SECURE 2.0 RMD starting ages, Uniform Lifetime Table math, first-year deadlines, IRA vs 401(k) aggregation, inherited IRA 10-year rules, QCD charity strategy, penalty relief, and a retirement withdrawal checklist.
• HSA explained: Health Savings Accounts, triple tax advantage and HDHP rules The only triple tax-free account — HDHP eligibility, 2026 contribution limits, HSA vs FSA, investing balances, receipt banking, Medicare transitions, beneficiary rules, and a retail savings checklist.
• Asset location explained: tax-efficient placement across taxable, IRA and 401(k) Which investments belong in which account — bonds and REITs in Traditional tax-deferred, growth equity in Roth, tax-efficient index ETFs in taxable, rebalancing without unnecessary gains, and a retail placement checklist.
• Commodities investing explained: gold, oil, ETFs and portfolio role Energy, metals, and agriculture — futures vs commodity ETFs, contango and roll yield, inflation hedging reality, and sizing real assets in a diversified portfolio.
• ETFs explained: exchange-traded funds and index investing How ETFs work, creation and redemption, expense ratios, tax efficiency, ETF types from broad equity to bonds, and building a low-cost passive core.
• Index funds explained: passive investing, market cap weighting and low-cost portfolios Own the market instead of picking stocks — S&P 500 vs total market benchmarks, cap-weight concentration, expense ratios and tracking error, index mutual funds vs ETFs, three-fund portfolios, and a retail checklist.
• Mutual funds explained: NAV pricing, active vs index and 401(k) investing Open-end fund structure, net asset value pricing, expense ratios and loads, target-date glide paths, tax distributions, mutual fund vs ETF trade-offs, and a retail evaluation checklist.
• Portfolio diversification and asset allocation explained Correlation, classic stock-bond mixes, rebalancing discipline, geographic and sector spread, and sizing crypto inside a survivable plan.
• REITs explained: real estate investment trusts, yields and portfolio role Own commercial real estate through stocks — equity vs mortgage REITs, FFO and AFFO, sector types, dividend taxes, ETF access, inflation sensitivity, and sizing a real estate sleeve.
• Portfolio rebalancing explained: drift bands, calendar vs threshold rules Allocation drift after rallies — target weights, tolerance bands, tax-aware rebalancing in taxable vs IRA accounts, crypto sleeve rules, and pairing with DCA.
• Dollar-cost averaging (DCA) explained Fixed-interval investing — how DCA smooths entry prices, lump-sum comparisons, crypto DCA pitfalls, and building a disciplined recurring-buy plan.
• Capital gains tax explained: short-term vs long-term rates, cost basis and crypto How investment gains are taxed — holding-period rules, FIFO vs specific lot ID, netting losses, NIIT surtax, mutual fund distributions, crypto dispositions, and a pre-sale checklist for taxable accounts.
• Tax-loss harvesting explained: wash sales, crypto losses and offsets Realize capital losses to offset gains — wash-sale windows, short-term vs long-term treatment, ETF substitute swaps, crypto staking income traps, and a taxable-account checklist.
• Wash sale rule explained: 30-day window, substantially identical securities and tax traps Why rebuying too soon disallows losses — the 61-day calendar, IRA cross-account traps, ETF substitute pairs, basis adjustments, Form 8949 reporting, and a year-end harvesting checklist.
• Dividend investing explained: yield, payout ratios and income strategies Cash dividends vs buybacks, dividend yield and payout ratio, DRIP reinvestment, qualified tax treatment, dividend ETFs, yield traps, and total return vs income.
• Flash loans explained: uncollateralized DeFi borrowing and atomic transactions Borrow millions with no collateral in one transaction — repay-or-revert atomicity, arbitrage and liquidation use cases, oracle manipulation attacks, fees, and a due-diligence checklist.
• MEV explained: maximal extractable value, sandwich attacks and user protection Profit from transaction ordering — front-running, sandwiches, and liquidations on Ethereum and Solana, searchers and Jito bundles, Flashbots private flow, slippage and RPC mitigations, and a retail checklist.
• DEX slippage and price impact explained: AMM curves, tolerance and MEV protection Price impact vs slippage vs spread — constant-product curve math, tolerance settings that invite sandwich attacks, route splitting, private mempools, and a retail swap checklist.
• Liquidity pools and AMM mechanics explained Constant-product pricing, LP fee economics, impermanent loss, slippage, concentrated liquidity, and when order books beat pools.
• Liquid staking explained: LSTs, exchange rates, DeFi risks and evaluation stETH, rETH, jitoSOL and mSOL mechanics — exchange-rate reward accrual, depeg dynamics, restaking layers, validator centralization, and a holder checklist.
• Impermanent loss explained: DeFi LP risk, math and mitigation Why LPs underperform holders when prices diverge — IL formulas at 2x and 4x moves, fee breakeven, concentrated liquidity amplification, pair-type risk, and a production checklist.
• DeFi explained: decentralized finance, lending, DEXs and risks On-chain lending and borrowing, AMM swaps, stablecoin designs, yield sources, smart contract and bridge risks, DeFi vs CeFi trade-offs, and a protocol evaluation checklist.
• Stablecoins explained: USDC, USDT, DAI and on-chain dollar mechanics Fiat-backed reserves, crypto-collateralized DAI, algorithmic peg failures, mint and burn on-chain, bridge and depeg risks, yield trade-offs, and a checklist before you hold dollar tokens.
• Inflation explained: CPI, core prices, and market impact Headline vs core CPI, demand-pull vs cost-push, base effects, inflation expectations, and how hotter or cooler prints move bonds and risk assets.
• Inflation hedging explained: TIPS, real assets and portfolio sizing Direct CPI hedges — TIPS and I-bonds — plus commodities, gold, REITs, and equities as inflation protection, breakeven traps, lag effects, crypto limits, and a sizing checklist.
• Interest rates explained: how Fed policy moves markets Fed funds rate, yield curves, real vs nominal rates, and how hikes and cuts transmit to stocks, bonds, housing, and crypto.
• Yield curve explained: inversion, recession signals and market impact Term structure shapes — normal, flat, and inverted curves, 2s10s and 3m10y spreads, Fed steepening and flattening, and portfolio implications for equities, bonds, and crypto.
• Market volatility and the VIX explained: fear gauges, spikes and portfolio risk Historical vs implied volatility, how the VIX is calculated from S&P 500 options, volatility clustering in selloffs, VIX product contango traps, and practical hedging without overfitting fear readings.
• Options trading fundamentals explained Calls vs puts, strike and expiration, premium and the Greeks, covered calls and protective puts, assignment risk, and when derivatives fit a retail portfolio.
• Options Greeks explained: delta, gamma, theta, vega and hedging Sensitivity measures that drive option P&L — delta hedge ratios, gamma convexity and pin risk, theta decay curves, vega and implied vol, portfolio aggregation, earnings vol crush, and a retail risk checklist.
• Covered calls options strategy explained: income, assignment and rolling Sell calls against stock you own — payoff profiles, strike and expiration selection, ex-dividend assignment traps, rolling up and out, wheel strategy basics, tax angles, and a retail checklist.
• Margin trading and leverage explained Initial vs maintenance margin, margin calls and liquidation, cross vs isolated accounts, crypto perpetuals and funding rates, and how borrowed exposure differs from options.
• Short selling explained: borrow mechanics, costs and squeeze risk Sell shares you do not own — locate and borrow, Reg T margin, borrow fees and dividends, unlimited loss asymmetry, short squeezes, puts and inverse ETF alternatives, and a retail checklist.
• Risk management and position sizing explained Per-trade risk budgets, stop-loss sizing formulas, risk/reward ratios, portfolio heat, fractional Kelly, daily loss limits, and common mistakes that blow up trading accounts.
• Sharpe ratio explained: risk-adjusted returns, Sortino and portfolio use Excess return per unit of volatility — formula intuition, annualization, Sortino vs Treynor vs information ratio, fund comparison pitfalls, crypto fat-tail caveats, and a production checklist.
• Stock order types explained: market, limit, stop and trailing orders Execution mechanics for retail traders — market vs limit fills, stop-loss and stop-limit triggers, trailing stops, time-in-force, extended-hours pitfalls, and matching orders to your risk plan.
• Technical analysis fundamentals explained Candlestick charts, trends, support and resistance, moving averages, RSI and MACD, volume confirmation, chart patterns, multi-timeframe analysis, and the limits of price-only trading.
• Economic calendar explained How to read macro event calendars — impact ratings, actual vs forecast, CPI and jobs releases, Fed days, and typical market reactions.

Security & identity

• Authentication vs authorization explained: AuthN, AuthZ, RBAC and access control Who you are vs what you may do — session and token AuthN, RBAC/ABAC/ReBAC models, OAuth scopes vs app permissions, JWT claim pitfalls, 401 vs 403, fail-closed enforcement, and a production checklist.
• SQL injection and XSS explained: web application security fundamentals The two classic injection attacks — parameterized queries vs string concatenation, stored/reflected/DOM XSS, context-aware escaping, blind SQLi, CSP as a safety net, and a production security checklist.
• CSRF and SSRF explained: cross-site and server-side request forgery Forged browser requests vs server-side URL fetch abuse — SameSite cookies, synchronizer tokens, step-up auth, SSRF allowlists, DNS re-validation, cloud metadata blocking, egress segmentation, and a production checklist.
• Content Security Policy (CSP) explained script-src, nonces, hashes, report-only rollout, connect-src for APIs and RPC, and stopping XSS without breaking SPAs.
• Cryptographic hashing explained: SHA-256, bcrypt, and password security One-way hash functions, salted password storage with Argon2 and bcrypt, HMAC authentication, Merkle trees, commit-reveal fairness, and common credential-leak mistakes.
• Merkle trees explained: hash trees, proofs and blockchain state Binary hash trees and Merkle roots — inclusion proofs, SPV light clients, Ethereum state tries, ZK rollup commitments, certificate transparency, and verification pitfalls.
• JWT explained: JSON Web Tokens, signing and security Header.payload.signature structure, HS256 vs RS256, access and refresh tokens, validation checklist, and common JWT pitfalls in APIs.
• OAuth 2.0 and OpenID Connect explained Authorization vs authentication, authorization code + PKCE, scopes, access and ID tokens, and common OAuth misconfigurations.
• Passkeys and WebAuthn explained: FIDO2 and phishing-resistant login Passwordless authentication — platform vs roaming authenticators, registration and assertion ceremonies, RP ID binding, recovery paths, and production deployment checklist.
• Secrets management explained: vaults, rotation and production security API keys, DB passwords, TLS certs, and signing keys — env vars vs secret managers, runtime injection, rotation schedules, least privilege, CI/CD hygiene, and a production checklist.
• TLS and HTTPS explained How TLS encrypts web traffic — certificates, CAs, the handshake, HSTS, mixed content, Let's Encrypt, and securing wallet and payment sites.

AI & technology

• Machine learning fundamentals explained Supervised, unsupervised, and reinforcement learning — features and labels, train/val/test splits, loss and gradient descent, overfitting, evaluation metrics, and the bridge from classical ML to LLMs.
• Python fundamentals explained: syntax, data structures and ecosystem Indentation and types, lists and dicts, functions and dataclasses, venv and pip, asyncio and the GIL, FastAPI services, stdlib highlights, and habits from notebooks to production.
• Regular expressions (regex) explained: patterns, groups and pitfalls Character classes, quantifiers, anchors, capturing groups, lookahead, greedy vs lazy matching, JavaScript and Python engine differences, ReDoS backtracking, and when a parser beats regex.
• Rust fundamentals explained: ownership, safety and systems programming Ownership and borrowing, Result and Option error handling, Cargo and crates, traits and generics, async concurrency, Solana on-chain programs, WASM compilation, and a production checklist.
• Deep learning explained: neural networks, backpropagation and training Stacked layers and nonlinear activations — forward pass and loss, backpropagation and optimizers, CNNs for vision, RNN-to-transformer bridge, regularization, GPUs, and when neural nets beat classical ML.
• Transfer learning explained: pre-trained models, fine-tuning and domain adaptation Reuse ImageNet and BERT backbones on small datasets — feature extraction vs partial and full fine-tuning, domain shift, negative transfer, LLM foundation models, data requirements, and a production checklist.
• Feature engineering explained: encoding, scaling, leakage and train-serve parity Transform raw columns into model-ready signals — numeric scaling, categorical encoding, datetime and text derivations, interaction terms, target leakage traps, feature stores, and a production checklist.
• Overfitting and cross-validation explained: bias-variance, k-fold and model selection Train/val/test splits, stratified and group k-fold CV, data leakage traps, regularization, early stopping, learning curves, and validation discipline for classical ML and LLM fine-tuning.
• Unsupervised learning and clustering explained: K-means, DBSCAN and segmentation Finding structure without labels — K-means step-by-step, hierarchical and density-based clustering, choosing K, silhouette scores, PCA preprocessing, customer segmentation, and a production checklist.
• Gradient boosting and ensemble learning explained: XGBoost, LightGBM and random forests Bagging vs boosting, gradient descent on residuals, XGBoost vs LightGBM vs CatBoost, hyperparameters and early stopping, feature importance, class imbalance, and when tree ensembles beat neural nets on tabular data.
• Precision, recall and F1 score explained: confusion matrix, thresholds and imbalanced data Why accuracy lies on skewed data — TP/FP/FN/TN, precision-recall tradeoff, F-beta scores, PR curves, threshold tuning, macro/micro averaging, and a production checklist.
• Computer vision fundamentals explained: CNNs, detection and segmentation Pixels to predictions — classification vs detection vs segmentation, ResNet and YOLO architectures, vision transformers and CLIP, training data discipline, mAP metrics, and production deployment pitfalls.
• Reinforcement learning explained: MDPs, Q-learning, PPO and RLHF Agents, environments, and reward signals — exploration vs exploitation, value-based and policy-gradient methods, reward shaping pitfalls, sample efficiency, and how RLHF aligns large language models.
• RLHF explained: human feedback, reward models, DPO and LLM alignment The post-training pipeline behind ChatGPT-class assistants — SFT demonstrations, pairwise preferences, reward modeling, PPO with KL penalties, DPO and RLAIF alternatives, and alignment failure modes.
• LLM function calling explained: tool schemas, APIs and production patterns JSON Schema tool definitions, the multi-turn call loop, parallel vs sequential execution, provider APIs (OpenAI, Anthropic, Gemini), strict mode, validation, security, and a production checklist.
• AI agents and tool use explained Function calling, ReAct planning loops, memory and RAG as tools, multi-agent handoffs, guardrails, cost control, and when workflows beat autonomy.
• LLM agent memory explained: working context, episodic logs and vector stores Memory tiers for persistent agents — conversation summarization, semantic vector recall, user profiles, write policies, tenant isolation, forgetting, and a production checklist.
• LLM sampling and decoding strategies explained: temperature, top-p and beam search From logits to text — greedy vs stochastic decoding, temperature scaling, top-k and nucleus sampling, repetition penalties, beam search, stop sequences, tuning by use case, and a production checklist.
• LLM speculative decoding explained: draft models, verification and speedups Faster autoregressive generation — draft-and-verify loops, acceptance-rate math, Medusa and EAGLE variants, vLLM integration, memory tradeoffs, and when speculation pays off in production.
• RAG explained: retrieval-augmented generation Embeddings, vector search, chunking strategies, hybrid retrieval, reranking, and evaluation for knowledge-grounded LLM apps.
• Hybrid search explained: BM25, vector retrieval and RAG fusion Combine keyword BM25 with dense embeddings — sparse vs dense trade-offs, reciprocal rank fusion, Elasticsearch and dual-index patterns, query routing, SPLADE sparse vectors, and a production checklist.
• LLM reranking explained: cross-encoders, two-stage retrieval and RAG quality Bi-encoder vs cross-encoder scoring, Cohere and BGE rerankers, reciprocal rank fusion with hybrid search, latency budgets, score thresholds, and a production checklist.
• LLM chain-of-thought reasoning explained: step-by-step prompting and reasoning models Zero-shot and few-shot CoT, self-consistency voting, tree-of-thought search, reasoning-native models (o1, DeepSeek-R1), latency and token costs, faithfulness pitfalls, and a production checklist.
• LLM embeddings explained: vectors, similarity search and model choice Dense text vectors, cosine similarity, contrastive training, embedding model families, Matryoshka dimensions, RAG indexing best practices, and retrieval pitfalls.
• LLM context windows explained Token limits, input vs output budgets, KV cache costs, RAG patterns, and choosing the right context size for agents and chat apps.
• LLM KV cache explained: prefill, decode and inference memory How transformers cache key and value tensors — prefill vs decode phases, memory scaling, GQA/MQA, PagedAttention, API prompt caching, and multi-turn chat tuning.
• LLM prompt caching explained: prefix reuse, API cost savings and layout patterns Provider-level prefix caching across requests — cached vs uncached token pricing, cache breakpoints, static-first RAG layout, multi-turn optimization, self-hosted analogs, and a production checklist.
• LLM evaluation and benchmarking explained Golden datasets, public benchmarks vs app evals, LLM-as-judge, RAG faithfulness metrics, CI regression suites, and production quality monitoring.
• LLM fine-tuning explained: LoRA, QLoRA and when to train Supervised fine-tuning vs prompting and RAG, parameter-efficient adapters, data prep, evaluation, deployment costs, and a decision framework for when training pays off.
• LLM guardrails explained: input filters, output policies and safe agents Pre/post-model safety rails, classifier sidecars, schema validators, tool allowlists, human-in-the-loop gates, red-team evals, and a production checklist for chatbots and autonomous agents.
• LLM hallucinations explained: causes, detection and fixes Why models invent facts and cite fake sources, types of confabulation, faithfulness metrics, RAG and verification mitigations, and a production reliability checklist.
• LLM model quantization and inference explained FP16 vs INT8 vs INT4, GPTQ and AWQ post-training quantization, KV cache and memory bandwidth, continuous batching, speculative decoding, and eval checklists after you shrink weights.
• LLM structured outputs explained: JSON Schema, validation and production JSON mode vs schema-constrained generation, function calling trade-offs, Pydantic/Zod schemas, validate-repair loops, streaming partial JSON, security pitfalls, and a production checklist for machine-readable LLM responses.
• LLM tokenization explained: BPE, tokens, and context costs Byte-pair encoding and SentencePiece — how text becomes token IDs, why counts differ from words, multilingual quirks, tiktoken counting, chat templates, and RAG chunk sizing.
• Prompt injection explained: LLM security and defenses Direct vs indirect injection, jailbreaks, RAG poisoning, tool-use abuse, and a practical defense checklist for chatbots and autonomous agents.
• Prompt engineering explained: writing effective LLM prompts Zero-shot and few-shot prompting, chain-of-thought, system prompts, structured JSON output, temperature tuning, and eval habits for reliable LLM apps.
• Vector databases explained: embeddings and ANN search Cosine similarity, HNSW and IVF indexes, metadata filtering, hybrid BM25+vector retrieval, pgvector vs managed stores, and sizing a vector index for RAG.
• Transformer architecture explained: self-attention and modern LLMs Why transformers replaced RNNs, Q/K/V self-attention, multi-head layers, positional encoding, encoder vs decoder-only stacks, KV cache, and how GPT-class models underpin RAG and fine-tuning.
• Multimodal AI models explained: vision, audio and unified LLMs CLIP contrastive training, vision-language transformers, cross-attention fusion, speech and video modalities, API patterns, failure modes, and production checklists for GPT-4o-class systems.
• Named entity recognition (NER) explained: BIO tagging, models and production Extract people, organizations, locations and domain-specific spans from text — BIO and BIOES tagging, spaCy and transformer NER, LLM JSON extraction, entity linking, evaluation metrics, and a production checklist.
• Mixture of experts (MoE) explained: sparse LLMs, routing and inference How MoE scales parameters without scaling per-token compute — gating routers, top-k expert selection, load balancing, Mixtral naming, VRAM vs FLOPs, quantization, and when dense models still win.
• Model Context Protocol (MCP) explained: AI tool servers, hosts and secure integrations The open standard wiring LLM hosts to external tools — MCP architecture, tools/resources/prompts, stdio vs HTTP transports, security pitfalls, and a production checklist for agent integrations.
• Diffusion models explained: DDPM, Stable Diffusion and image generation Forward and reverse noise processes, latent diffusion with VAEs, CLIP text conditioning, classifier-free guidance, sampling schedulers, img2img and inpainting, and inference cost trade-offs.
• Edge AI and on-device inference explained: NPUs, hybrid LLMs and privacy Running models on phones and laptops — Neural Engines and NPUs, INT4 quantization for local LLMs, hybrid local-cloud routing, privacy tradeoffs, and when edge beats cloud APIs.
• LLM model distillation explained: teacher-student training and model compression Transfer capability from frontier teachers to smaller students — soft-label logits distillation, synthetic response pipelines, temperature scaling, evaluation traps, and pairing with quantization.
• LLM inference serving explained: batching, engines and production deployment From single-GPU prototypes to multi-tenant APIs — continuous batching, vLLM and TGI, TTFT vs tokens-per-second, autoscaling queues, speculative decoding, and an SLO checklist for production LLM stacks.

Backend & data

• Database transactions and isolation levels explained: ACID, MVCC and deadlocks ACID guarantees, Read Committed through Serializable, dirty reads and phantom rows, MVCC vs row locks, deadlocks, optimistic versioning, and outbox patterns for multi-service apps.
• Webhooks explained Push vs poll, HMAC signature verification, delivery retries, idempotency keys, and reliable handlers for payments and SaaS events.
• API rate limiting explained Token bucket vs sliding window, HTTP 429 and Retry-After headers, exponential backoff with jitter, and distributed quota pitfalls.
• Application caching explained: Redis, cache-aside, and invalidation Cache-aside vs write-through, Redis and in-memory stores, TTL and eviction, invalidation patterns, and thundering herd protection.
• N+1 query problem explained: detection, fixes and ORM pitfalls One list query plus N child lookups — lazy-loading traps, eager loading and JOINs, batched IN queries, DataLoader batching, microservice fan-out, and a production checklist.
• Data structures and algorithms fundamentals explained: Big O, arrays, trees and graphs Hash maps for lookup, heaps for priority, B-trees for indexes — Big O complexity, linear structures, trees and graphs, sorting and binary search, production trade-offs, and a structure-selection checklist.
• Database indexing explained: B-trees, compound keys and EXPLAIN plans B-tree indexes, compound keys, covering indexes, EXPLAIN plans, and when indexes help or hurt write throughput.
• Database migration strategies explained: zero-downtime schema changes Versioned migrations, expand-contract deploys, batched backfills, ALTER TABLE locking, rollback discipline, and sharded migration pitfalls.
• Database normalization explained: 1NF, 2NF, 3NF and denormalization Functional dependencies, update anomalies, normal forms with a worked e-commerce example, BCNF intuition, and when to denormalize for read performance.
• Database replication explained: read replicas, WAL shipping, lag and failover Primary vs replica topologies, sync vs async replication, PostgreSQL WAL and MySQL binlog shipping, replication lag and read-your-writes, read/write routing, failover and split-brain prevention, and a production checklist.
• Database sharding explained: horizontal partitioning, shard keys and hotspots Splitting rows across database nodes — shard key design, consistent hashing, cross-shard query patterns, celebrity hotspots, rebalancing migrations, and when replicas beat sharding.
• Distributed locking explained: leases, Redis, fencing tokens and safe concurrency Coordinate exclusive work across replicas — lease TTL and renewal, Redis SET NX and Redlock, PostgreSQL advisory locks, ZooKeeper/etcd, fencing tokens against stale holders, and when idempotency beats a lock.
• Distributed systems consistency explained: CAP, eventual and strong models ACID vs BASE, the CAP theorem, strong vs eventual vs causal consistency, quorum replication, read-your-writes, cache and queue boundaries, and choosing guarantees per data path.
• Microservices architecture explained: boundaries, communication and pitfalls Monolith vs microservices trade-offs, domain-driven service boundaries, sync REST/gRPC vs async events, database-per-service, sagas and outbox, API gateways, resilience patterns, and when not to split.
• Saga pattern explained: distributed transactions, compensation and orchestration Local transactions across microservices — choreography vs orchestration, compensating transactions, idempotency and outbox, failure recovery, stuck-state alerts, and a production checklist.
• Docker fundamentals explained: images, containers, and Compose Images vs containers, Dockerfile layer caching, multi-stage builds, volumes and networking, Docker Compose for local stacks, registries, security hygiene, and when to graduate to Kubernetes.
• Database connection pooling explained Why connections are expensive, pool sizing math, PgBouncer transaction mode, serverless connection storms, leak detection, and monitoring checkout queues.
• SQL fundamentals explained: queries, joins, and transactions Relational tables and keys, SELECT and WHERE, INNER and LEFT JOINs, GROUP BY aggregations, INSERT/UPDATE/DELETE, ACID transactions, and safe parameterized queries.
• SQL joins explained: INNER, LEFT, FULL OUTER and anti-join patterns Combine tables without losing rows — join types, ON vs WHERE NULL traps, self joins, accidental Cartesian products, NOT EXISTS anti-joins, multi-table chains, and indexing join keys.
• API pagination explained: offset, cursor and keyset patterns Offset/limit vs opaque cursors vs keyset seeks, stable sort tie-breakers, response envelopes, filter consistency, GraphQL connections, indexing for flat page latency, and a production checklist.
• API versioning explained: URL path, headers, deprecation and sunset Breaking vs additive changes, path vs header vs media-type versioning, GraphQL deprecation and protobuf services, Sunset and Deprecation headers, webhook event versioning, parallel support windows, and a production checklist.
• REST API design explained Resource naming, HTTP verbs, status codes, pagination, versioning, idempotency keys, and error shapes integrators expect.
• Idempotency explained: safe retries, API keys and distributed systems What idempotent means in practice — HTTP verb semantics, Stripe-style idempotency keys, database unique constraints, queue consumers, webhook dedup, and a production checklist.
• Dead letter queues explained: poison messages, retries and recovery Quarantine failing async jobs — max receive counts, SQS DLQs, RabbitMQ dead-letter exchanges, Kafka DLT topics, retryable vs terminal errors, redrive runbooks, idempotent replay, and a production checklist.
• Transactional outbox pattern explained: atomic events without dual writes Publish domain events in the same database transaction as your business row — dual-write failure modes, polling vs CDC relays, Debezium, ordering by aggregate ID, inbox dedup, saga pairing, and a production checklist.
• Message queues explained: Kafka, RabbitMQ, and SQS Point-to-point vs pub/sub, delivery guarantees, dead-letter queues, partitioning for ordering, idempotent consumers, and when async messaging beats direct HTTP.
• Event-driven architecture explained Events vs commands, pub/sub and message queues, delivery guarantees, idempotent consumers, and when async beats synchronous REST.
• CQRS explained: command-query split, read models and projections Separate write-optimized command handlers from read-optimized query models — synchronous vs async projections, eventual consistency UX, pairing with event sourcing, idempotent projectors, and when CRUD is enough.
• Event sourcing explained: event stores, projections and CQRS Append-only domain events as the system of record — aggregates, snapshots, read-model projections, schema versioning, replay jobs, and when immutable history beats CRUD.
• GraphQL API design explained Schema-first types, queries and mutations, resolvers, DataLoader batching, cursor pagination, error handling, and when GraphQL beats REST.
• gRPC and Protocol Buffers explained: RPC, schemas and streaming HTTP/2 transport, .proto schema design, unary and streaming RPCs, deadlines and interceptors, versioning, and when gRPC beats REST for microservices.
• Observability explained: metrics, logs, and tracing The three pillars of observability, RED/USE methods, structured logging, OpenTelemetry, SLOs, correlation IDs, and what to instrument first.
• Chaos engineering explained: fault injection, game days and resilience testing Hypothesis-driven failure experiments, blast-radius control, latency and dependency fault injection, game days vs continuous chaos, Chaos Mesh and FIS tooling, abort guardrails, and pairing with circuit breakers.
• Feature flags explained: gradual rollouts, kill switches, and safe deployments Release toggles vs ops kill switches, percentage rollouts and user targeting, flag lifecycle and debt prevention, and pairing flags with CI/CD, Kubernetes, and observability.
• Bloom filters explained: probabilistic membership, false positives and production use Compact bit-array membership tests — k hash functions, false positive rate math, counting and scalable variants, Redis Bloom, LSM disk skip patterns, cache penetration defense, and a production checklist.
• Blue-green and canary deployments explained: zero-downtime release strategies Traffic switching vs gradual rollouts — dual environments, weighted canary gates, database expand-contract, health checks, automated rollback, and pairing with feature flags.
• CI/CD pipelines explained: continuous integration and deployment Automated build-test-deploy flows, continuous delivery vs deployment, blue-green and canary strategies, secrets hygiene, migrations, and rollback playbooks.
• Circuit breaker pattern explained: fail fast, fallbacks and resilience Closed, open, and half-open states — failure-rate thresholds, cascading outage prevention, pairing with timeouts and bulkheads, degraded fallbacks, and a production checklist.
• Git fundamentals explained: branches, commits and workflows Distributed version control — staging area, branching models, merge vs rebase, pull requests, conflict resolution, tags and releases, and habits that keep main deployable.
• Software design patterns explained: creational, structural and behavioral Gang of Four patterns that still matter — factory, strategy, observer, adapter, repository, dependency injection — plus singleton pitfalls, MVC, event-driven cousins, and when simpler code wins.
• Software testing fundamentals explained: unit, integration and E2E The test pyramid, arrange-act-assert, mocks vs fakes, integration and browser E2E patterns, TDD basics, flaky-test hygiene, and wiring tests into CI gates.
• Kubernetes fundamentals explained: pods, Deployments, and Services Cluster architecture, pods and Deployments, Services and Ingress, ConfigMaps and Secrets, resource limits, HPA, kubectl workflows, and when K8s beats simpler hosting.
• Serverless computing explained: FaaS, cold starts and when to use it Function-as-a-service platforms, event triggers, cold starts and concurrency limits, stateless design, pricing trade-offs, edge Workers, and a production checklist.
• Load balancing explained: L4 vs L7, algorithms and health checks Horizontal scaling entry points — round robin vs least connections, Layer 4 vs Layer 7 balancers, health checks, sticky sessions, TLS termination, and production pitfalls.
• Reverse proxy explained: nginx, TLS termination and routing Forward vs reverse proxies, path-based routing, upstream pools, WebSocket upgrades, edge rate limiting, caching at the proxy, and fixing 502 errors in production.
• API gateway explained: routing, auth, rate limits and microservices Gateway vs reverse proxy, JWT and API-key validation at the edge, per-consumer throttling, BFF aggregation, managed vs self-hosted Kong/Envoy, canary routing, and a production checklist.

Web & performance

• Web image optimization explained: WebP, AVIF, srcset, and lazy loading Modern formats, responsive srcset and sizes, fetchpriority for LCP heroes, width/height for CLS, CDN pipelines, and build-time compression for content sites.
• Web font optimization explained: WOFF2, font-display, and Core Web Vitals Load custom fonts without hurting LCP or CLS — WOFF2 and variable fonts, font-display swap vs optional, preloading, subsetting, self-hosting, and size-adjust fallback matching.
• DNS explained: domain name system and record types Recursive vs authoritative resolvers, A/AAAA/CNAME/MX/TXT records, TTL and propagation, DNSSEC, and debugging lookups with dig.
• TCP/IP fundamentals explained: layers, packets, ports and handshakes The four-layer stack, IP addressing and routing, TCP vs UDP, three-way handshake, ports and sockets, NAT, MTU black holes, and a network debugging checklist.
• CDN explained: content delivery networks and edge caching Edge PoPs, origin pull, cache keys, purge strategies, TLS at the edge, DDoS shielding, and pairing CDNs with HTTP cache headers for global performance.
• Service workers and PWA explained: offline caching and installable web apps Service worker lifecycle, cache-first and stale-while-revalidate strategies, web app manifests, offline fallbacks, push notifications, Workbox, and PWA vs native trade-offs.
• Browser storage explained: cookies, localStorage, and IndexedDB HTTP cookies and SameSite rules, localStorage vs sessionStorage, IndexedDB transactions, quota limits, and secure patterns for auth tokens and offline data.
• Browser critical rendering path explained: DOM, CSSOM, layout and paint How browsers turn HTML and CSS into pixels — render tree construction, render-blocking resources, compositor layers, layout thrashing, and CRP optimization for LCP and CLS.
• CORS explained: cross-origin requests Same-origin policy, preflight OPTIONS, Access-Control-Allow headers, credentials mode, and fixing blocked fetch calls in SPAs and dApps.
• HTTP caching explained Cache-Control, ETags, CDN edge caches, stale-while-revalidate, and what to set on HTML vs fingerprinted static assets.
• HTTP/2 and HTTP/3 explained: multiplexing, QUIC and modern web performance HTTP/1.1 limits, HTTP/2 binary framing and HPACK, QUIC over UDP, head-of-line blocking fixes, ALPN negotiation, CDN fallback, and production verification.
• Web Workers explained: dedicated workers, postMessage and off-main-thread JavaScript Run CPU-bound JavaScript on background threads — dedicated vs shared workers, postMessage and transferable buffers, worker pools, bundler setup, WASM pairing, and INP improvements without blocking the UI.
• Debouncing and throttling explained: search, scroll and API rate control Coalesce high-frequency browser events — trailing vs leading edge debounce, scroll throttle, requestAnimationFrame coalescing, React hook patterns, AbortController, and INP-friendly handlers.
• JavaScript event loop explained: call stack, tasks and microtasks How JavaScript schedules work on one thread — macrotasks vs microtasks, Promises and async/await, requestAnimationFrame, Workers, and keeping INP responsive.
• Node.js fundamentals explained: runtime, modules and async I/O V8 and libuv on the server — CommonJS vs ESM, npm and lockfiles, core built-ins, streams and backpressure, HTTP services, webhooks, graceful shutdown, and production checklist.
• Date, time and timezones explained: UTC, DST and ISO 8601 Instants vs civil time, UTC storage, ISO 8601 and Unix timestamps, daylight saving gaps and overlaps, JavaScript Date pitfalls, Intl and Temporal, database patterns, and DST test fixtures.
• SEO fundamentals explained: on-page, technical SEO and rankings How search engines crawl and rank pages — title tags, meta descriptions, canonical URLs, sitemaps, Core Web Vitals, internal linking, structured data, and content quality that earns organic traffic.
• JSON-LD structured data for articles Article and NewsArticle schema — required properties, Rich Results testing, common mistakes, and a publisher checklist for static sites.
• Core Web Vitals explained: LCP, INP, and CLS What Google measures for page speed and responsiveness — thresholds, CrUX field data, and fixes for publishers and developers.
• WebSockets and server-sent events explained Real-time web APIs — polling vs SSE vs WebSockets, handshake, heartbeats, reconnect logic, and scaling behind load balancers.
• Web accessibility (a11y) explained WCAG and POUR principles, semantic HTML, keyboard navigation, ARIA roles, color contrast, focus management, and testing for screen readers.
• SSR vs CSR vs SSG vs ISR explained Web rendering strategies — client vs server vs build time, hydration, caching trade-offs, SEO impact, and when to use each pattern in modern apps.
• TypeScript fundamentals explained Static typing over JavaScript — primitives and unions, interfaces vs types, generics, narrowing, strict compiler options, and adopting TS in web and API codebases.
• React fundamentals explained: components, hooks and state Declarative UI with function components — JSX, props, useState and useEffect, controlled inputs, context, list keys, performance habits, and fitting React into modern stacks with TypeScript and SSR.
• Frontend state management explained: local, global and server state useState vs Context vs Redux Toolkit vs Zustand vs TanStack Query — four state categories, decision framework, selectors, URL state, and mistakes that cause re-render storms.
• CSS Flexbox and Grid layout explained One-dimensional Flexbox vs two-dimensional Grid — axes, justify and align, fr units, auto-fit card grids, container queries, responsive patterns, and layout pitfalls that hurt CLS.
• Responsive web design explained: mobile-first, breakpoints and fluid layouts Mobile-first CSS, viewport meta tag, content-driven breakpoints, fluid typography with clamp(), container queries, touch targets, responsive images, and Core Web Vitals testing across viewports.

Game development

• Game combat systems explained: hitboxes, frame data, damage and feel Real-time and turn-based combat pipelines — hitboxes vs hurtboxes, startup/active/recovery frames, i-frames, damage formulas, combos, knockback, enemy telegraphs, multiplayer authority, and a production checklist.
• Game achievements and trophies explained: design, tracking and platform integration Optional milestones and completion goals — unlock conditions, hidden vs visible trophies, Steam/Xbox/PlayStation APIs, event-driven tracking, anti-grind patterns, platinum design, live-service DLC rules, and a production checklist.
• Game behavior trees explained: selectors, sequences and NPC AI Decision hierarchies for enemy AI — composite nodes, decorators, blackboards, tick and abort semantics, patrol-chase-attack patterns, engine tooling, and BT vs FSM vs utility AI.
• Game economy design explained: sources, sinks, inflation and monetization Balanced virtual economies — soft and hard currency, sources and sinks, progression curves, loot tables, F2P ethics, live-service tuning, and multiplayer trading pitfalls.
• Game accessibility explained: visual, motor, audio and cognitive design Inclusive game design — colorblind modes, remappable controls, subtitle and caption standards, photosensitivity toggles, difficulty assists, cognitive clarity, platform certification, and a production checklist.
• Game analytics and player retention explained: metrics, funnels and live ops Telemetry that drives retention — D1/D7/D30 cohort curves, event schemas, FTUE funnels, session KPIs, A/B testing discipline, privacy and platform compliance, pipeline failure modes, and a production checklist.
• Game AI perception explained: vision cones, hearing, memory and stealth NPC sensory systems — field-of-view and line-of-sight raycasts, noise propagation and hearing radii, last-known-position memory, alert and search states, stealth detection meters, performance budgets, and multiplayer authority.
• Game animation blending explained: crossfades, blend trees and layers Skeletal clips and poses — crossfade transitions, 1D and 2D blend trees for locomotion, animation layers and masks, root motion vs in-place, IK foot planting, and performance on PC and mobile.
• Game audio explained: SFX, music, mixing and Web Audio API Sound effects and music pipelines — buses and mixing, Web Audio API, spatial panning, adaptive stems, compression formats, latency, and mobile autoplay unlock.
• Game camera systems explained: follow, orbit, FOV and collision Framing and game feel — follow rigs with smoothing and look-ahead, wall collision pull-in, screen shake, 2D parallax, split-screen, cinematics, and Unity, Godot, and browser patterns.
• Game difficulty curves explained: flow, spikes and adaptive tuning Challenge over time — flow state and frustration bands, linear vs sawtooth curves, skill vs power progression, rubber-banding and DDA, difficulty settings, churn analytics, and a production checklist.
• Game dialogue systems explained: branching trees, Ink, Yarn and NPC barks NPC conversation plumbing — line data models, branching vs reactive barks, Ink and Yarn Spinner middleware, flags and reputation, localization export, subtitle accessibility, VO hooks, quest integration, and a production checklist.
• Game enemy spawning and wave systems explained: triggers, budgets and pacing Horde and arena pacing — trigger volumes, spawn point validation, wave tables, population caps, budget curves, telegraphing, object pooling integration, procedural vs authored packs, and multiplayer authority.
• Game fog of war explained: visibility, line of sight and map memory Information asymmetry in strategy games — unexplored shroud vs explored memory vs live vision, vision radii and height bonuses, LOS raycasts and shadow-casting, team-shared masks, minimap fog shaders, server-authoritative multiplayer filtering, and a production checklist.
• Game input handling explained: keyboard, mouse, touch and gamepad Polling vs events, action mapping, Gamepad API dead zones, touch ergonomics, coyote time and input buffers, multiplayer authority, and accessibility remapping.
• Game inventory systems explained: items, stacking, equipment and authority Item definitions vs instances, list vs grid bags, equipment stat aggregation, capacity limits, loot pickup, server-authoritative grants, save persistence, anti-duplication, and inventory UI patterns.
• Game juice and game feel explained: hit stop, screen shake and feedback Satisfying game polish — hit pause, camera kick, squash and stretch, layered particles and audio, UI micro-interactions, graded intensity tiers, and accessibility toggles.
• Game tutorial and onboarding design explained: FTUE, teaching loops and retention First-time user experience — show-don't-tell, gated mechanics, contextual hints, skip paths, safe failure, mobile pacing, analytics funnels, and accessibility in tutorials.
• Game utility AI explained: consideration curves, scoring and action selection NPC decision scoring — considerations and response curves, flee-vs-fight tuning, weighted random selection, blackboard inputs, hybrid BT/FSM stacks, multiplayer authority, debug overlays, and a production checklist.
• Game UI and HUD design explained: menus, health bars, minimaps and readability Diegetic vs screen-space HUD, health and ammo bars, minimaps and objectives, menu depth, console safe zones, mobile thumb reach, accessibility presets, and engine layout patterns.
• Game save systems explained: serialization, slots and cloud sync Persistence design — profile vs campaign saves, JSON and binary formats, checkpoints and autosave, atomic writes, schema migration, cloud conflict resolution, ECS hydration, and corruption recovery.
• Game particle systems explained: emitters, GPU sims and VFX budgets Explosions, sparks, and smoke — CPU vs GPU simulation, emitter modules, billboards and texture atlases, lifetime curves, pooling, sorting, overdraw profiling, and mobile fill-rate limits.
• Game shaders explained: vertex, fragment, PBR and WebGL GPU rendering pipeline — vertex and fragment programs, GLSL and HLSL, PBR materials, shader graphs vs code, WebGL browser constraints, and fill-rate performance on PC and mobile.
• Game level design explained: flow, pacing and player guidance Greybox blockout and metrics, sightlines and landmarks, difficulty ramps, environmental storytelling, 2D vs 3D layouts, multiplayer map balance, and playtesting iteration.
• Game lighting explained: real-time, baked GI, shadows and mood Directional, point and spot lights, baked vs dynamic global illumination, cascaded shadow maps, PBR and reflection probes, volumetric fog, day-night cycles, readability, and performance budgets.
• Game localization and i18n explained: strings, RTL, LQA and shipping Internationalization vs localization — string externalization, ICU plurals, RTL mirroring, font and VO pipelines, pseudo-localization, TMS workflows, cultural adaptation, platform cert, and a production checklist.
• Game loot tables and weighted random explained: drop rates, pity and server authority Loot table structure, cumulative and alias selection, rarity tiers, pity and bad-luck protection, seeded vs server rolls, Monte Carlo testing, drop-rate disclosure, and inventory grant pipeline.
• Game narrative design explained: story, lore, player agency and ludonarrative harmony Delivery methods from cutscenes to environmental storytelling, branching vs linear structure, character arcs, lore bibles, ludonarrative dissonance fixes, and a production checklist.
• Game quest design explained: objectives, rewards and player motivation Main vs side quests, clear objectives, reward pacing, branching and quest chains, journal and waypoint UX, live-service dailies, fetch-quest pitfalls, and a production checklist.
• Game LOD (level of detail) explained: meshes, textures and performance Mesh LOD chains, screen-space switch metrics, texture mipmaps and streaming, impostors and HLOD, pop-in fixes, collision separation, and frame-budget profiling on PC and mobile.
• Game tilemaps explained: grids, layers, autotiling and collision 2D world building — tile coordinates and tilesets, render vs collision layers, blob and Wang autotiling, orthogonal vs isometric vs hex, chunk streaming, pathfinding grids, Tiled import, and a production checklist.
• Game terrain generation explained: heightmaps, noise, biomes and streaming Landscape pipelines — layered Perlin and Simplex noise, mesh chunking and LOD skirts, splat maps and triplanar blending, hydraulic erosion, biome masks, Poisson vegetation scatter, navmesh baking, and a production checklist.
• Procedural generation in games explained: noise, dungeons, and seeds Algorithmic content pipelines — Perlin and Simplex noise for terrain, BSP and cellular automata dungeons, weighted loot tables, seeded RNG, chunk streaming, and validation for fair replayable worlds.
• Pathfinding in games explained: A*, heuristics, grids and navmeshes Graph search for AI navigation — A* with admissible heuristics, grid vs navmesh representations, BFS and Dijkstra comparisons, path smoothing, hierarchical search, and frame-budget performance.
• Game steering behaviors explained: seek, flee, flocking and local AI Reynolds locomotion — seek, flee, arrive, wander, pursuit and evade, separation/alignment/cohesion boids, obstacle avoidance feelers, weighted blending with navmesh pathfinding, and a production checklist.
• Entity component system (ECS) in games explained Data-oriented game architecture — entities as IDs, components as data, systems as logic, archetype storage, queries, scheduling, and when ECS beats deep inheritance trees.
• Collision detection in games explained Broad vs narrow phase, AABB and circle tests, SAT for polygons, spatial hashing, continuous collision for fast projectiles, layer masks, and frame-budget performance.
• Game physics explained: rigid bodies, integration, and collision response Rigid body simulation — forces and gravity, Euler and Verlet integration, fixed timesteps, impulse resolution, restitution and friction, 2D and 3D engines, determinism, and performance.
• Game player progression systems explained: XP, levels, skill trees and meta Long-term engagement design — XP curve math, skill vs power growth, unlock trees, prestige loops, roguelike meta-progression, battle pass pacing, multiplayer normalization, and churn analytics.
• Game loop and frame timing explained Input, update, and render cycles — delta time, fixed vs variable timestep, requestAnimationFrame, frame budgets, interpolation, and deterministic outcomes.
• Game leaderboards explained: rankings, score submission, anti-cheat and seasons Global vs friends vs seasonal boards, server-authoritative validation, tie-breaking, percentile ranks, division brackets, anti-cheat layers, UI retention patterns, and live-service reset ops.
• Game matchmaking explained: MMR, queues, skill rating and fair matches Elo, Glicko and TrueSkill rating systems, progressive queue widening, party MMR inflation, regional ping buckets, ranked seasons, smurf detection, and backend match-ticket architecture.
• Game networking and multiplayer netcode explained Client-server authority, tick rates and snapshots, client-side prediction and reconciliation, interpolation, lag compensation, rollback for fighters, and WebSocket vs WebRTC in browser games.
• Game object pooling explained: reuse, GC pressure and frame budgets Allocation-free combat — prewarm and cap pools, acquire/release APIs, OnSpawn reset discipline, Unity and Godot patterns, bullet and VFX pooling, double-release guards, and a production checklist.
• Game state machines explained: FSMs, transitions, and AI behavior Finite state machines for player controllers and enemy AI — states, transition guards, hierarchical FSMs, animation blending, behavior trees vs FSMs, and debugging transition explosion.
• WebAssembly (WASM) explained Portable binary format for near-native browser speed — linear memory, JS interop, compiling from Rust with wasm-pack, WASI, security sandbox, and when WASM beats JavaScript.

Free tools

• Solana transaction lookup Verify a payment landed — status, amount, and addresses from any tx signature.
• Solana wallet balance checker Check mainnet SOL balance before sending a micropayment.
• SOL ↔ lamports converter Instant unit conversion — 1 SOL = 1,000,000,000 lamports.
• Solana address validator Check base58 wallet and program IDs — no RPC required.
• Transaction signature validator Check base58 tx IDs — useful after Solana Pay or wallet sends.
• All tools Browse every free utility on Solana Garden.

Try it live

Beat roll of 4 — 0.001 SOL Free demo first

Garden Dice is our wallet-native pay-per-roll game. Every guide links to a working demo. Press kit for sharing.