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.
• Market capitalization explained: size tiers, float vs fully diluted and valuation context Share price times shares outstanding — large/mid/small/micro cap bands, float vs fully diluted counts, market cap vs enterprise value, index weighting, common misconceptions, worked example, and an investor checklist.
• Stock splits explained: forward splits, reverse splits and shareholder impact How splits rescale share count and price without changing market cap — forward vs reverse mechanics, EPS and dividend adjustments, cost basis rules, splits vs stock dividends and buybacks, worked example, and an investor checklist.
• 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.
• Economic moats explained: competitive advantages, ROIC and durability Warren Buffett's moat concept — network effects, switching costs, cost advantages, intangible assets, efficient scale, financial statement signals, widening vs eroding tests, sector patterns, and an investor checklist.
• 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.
• SEC filings explained: 10-K, 10-Q, 8-K, EDGAR and how to research stocks Navigate EDGAR like an analyst — annual and quarterly reports, material 8-K events, proxy statements, insider Form 4 trades, S-1 IPO docs, MD&A and risk factors, XBRL data, worked example, decision table, and an investor checklist.
• Liquidity ratios explained: current ratio, quick ratio and working capital Short-term solvency from the balance sheet — current, quick, and cash ratios, working capital trends, cash conversion cycle links, sector benchmarks, accounting red flags, and an investor checklist.
• Current ratio explained: formula, sector benchmarks and balance-sheet liquidity red flags Short-term solvency from current assets over current liabilities — sector benchmark bands, current vs quick and cash ratios, Harbor Retail 3.4→2.2 refactor, technique decision table vs acid test alone, pitfalls, and checklist.
• Quick ratio (acid test) explained: formula, benchmarks and liquidity red flags Near-cash liquidity without inventory — quick vs current and cash ratios, covenant traps, sector benchmarks, Harbor Components 0.6→1.1 refactor, technique decision table vs working capital, pitfalls, and checklist.
• Cash ratio explained: formula, stress liquidity and balance-sheet red flags Absolute liquidity from cash and equivalents alone — cash vs current and quick ratios, restricted cash traps, sector benchmarks, Harbor Digital 0.11→0.38 stress refactor, technique decision table vs acid test alone, pitfalls, and checklist.
• Cash and cash equivalents explained: balance sheet liquidity, restricted cash and free cash flow ASC 305 components and three-month maturity rule — unrestricted vs restricted vs pledged cash, roll-forward and CFO bridge, liquidity ratio links, Harbor Fintech 38→8% screen-miss refactor, decision table vs headline cash, pitfalls, and checklist.
• Current assets explained: balance sheet liquidity, operating cycle and cash conversion ASC 210 classification and component stack — cash, AR, inventory, prepaids and other current lines, current vs non-current split, roll-forward and CFO bridge, Harbor Retail 45→10% liquidity-screen miss refactor, decision table vs single-line ratios, pitfalls, and checklist.
• Short-term investments and marketable securities explained: balance sheet liquidity, fair value and OCI ASC 320 classification — trading vs AFS vs HTM, fair value and unrealized losses in OCI, maturity and credit ladders, roll-forward and CFI bridge, Harbor Semiconductor 41→9% liquidity-screen miss refactor, decision table vs cash equivalents alone, pitfalls, and checklist.
• Cash conversion cycle explained: DIO, DSO, DPO and working capital efficiency Days from paying suppliers to collecting from customers — CCC = DIO + DSO − DPO, negative CCC models, sector benchmark bands, FCF and working capital links, accounting traps, worked example, and an investor checklist.
• Accounts payable explained: trade payables, working capital and cash flow Supplier obligations on the balance sheet — GRNI and three-way match, AP aging, indirect-method CFO bridge, Harbor Logistics 33→7% FCF preview refactor, decision table vs DPO alone, pitfalls, and checklist.
• Days payable outstanding (DPO) explained: accounts payable turnover, supplier terms and cash flow How long a company takes to pay suppliers — DPO and AP turnover formulas, CCC and FCF links, reverse-factoring traps, Harbor Foods 24→38 day refactor, technique decision table vs free cash flow, pitfalls, and checklist.
• Accounts receivable explained: trade receivables, working capital and cash flow Customer obligations on the balance sheet — gross vs net AR, revenue recognition timing, AR roll-forward and aging, indirect-method CFO bridge, Harbor Wholesale 42→9% FCF preview refactor, decision table vs DSO alone, pitfalls, and checklist.
• Days sales outstanding (DSO) explained: accounts receivable turnover, collection quality and red flags How fast customers pay after a sale — DSO and AR turnover formulas, CCC and FCF links, channel-stuffing traps, Harbor Industrial 58→41 day refactor, technique decision table vs revenue growth, pitfalls, and checklist.
• Allowance for doubtful accounts and bad debt expense explained: CECL reserves, AR contra-assets and earnings quality Trade receivable credit reserves — gross vs net AR, ASC 326 CECL roll-forward, allowance ratio screens, Harbor Telecom 2.1→0.4% under-reserve refactor, decision table vs DSO alone, pitfalls, and checklist.
• Days inventory outstanding (DIO) explained: inventory turnover, stock efficiency and cash flow How long inventory sits before sale — DIO and inventory turnover formulas, CCC and FCF links, obsolescence and channel-stuffing traps, Harbor Components 52→38 day refactor, technique decision table vs gross margin, pitfalls, and checklist.
• Working capital explained: net WC, operating cycle and cash tied up in operations Short-term operating liquidity on the balance sheet — NWC formula, operating vs total WC, change in NWC and FCF bridge, business-model intensity, Harbor Distributors $32M ABL overadvance refactor, technique decision table vs CCC and liquidity ratios, pitfalls, and checklist.
• Prepaid expenses explained: current assets, cash-before-expense timing and working capital Cash paid before expense recognition — insurance and subscription prepaids, amortization schedules, indirect-method CFO adjustments, Harbor Media 29→6% cash-quality refactor, decision table vs accrued liabilities, pitfalls, and checklist.
• Working capital to sales ratio explained: NWC intensity, operating WC and cash drain Cash tied up per revenue dollar — NWC/revenue and operating WC formulas, AR and inventory sub-ratios, sector benchmarks, CCC links, Harbor Apparel 11→26% operating WC refactor, decision table vs current ratio, pitfalls, and checklist.
• Long-term debt and notes payable explained: balance sheet, maturities and leverage risk Contractual borrowings on the liability side — current vs non-current classification, debt roll-forward, financing cash flow bridge, covenant screens, Harbor Infrastructure 28→9% leverage-miss refactor, decision table vs D/E alone, pitfalls, and checklist.
• Lease liabilities and operating leases explained: ASC 842, IFRS 16 and adjusted leverage Capitalized operating leases on the balance sheet — ROU assets, discount rates, lease roll-forward, adjusted net debt and FCCR, Harbor Retail 34→11% leverage-miss refactor, decision table vs debt-only screens, pitfalls, and checklist.
• Debt-to-equity ratio explained: leverage, capital structure and financial risk How lenders versus shareholders fund the business — gross and net D/E formulas, debt-to-capital and interest coverage links, ROE amplification, sector leverage bands, off-balance-sheet traps, and an investor checklist.
• Interest coverage ratio explained: EBIT, debt service and credit risk Whether operating earnings can pay interest — EBIT and EBITDA coverage formulas, covenant thresholds, sector benchmarks, cyclical normalization, rate stress tests, accounting traps, and an investor checklist.
• Interest expense explained: income statement placement, cash vs reported financing cost and investor analysis Borrowing cost below EBIT on the income statement — coupon vs accrual components, capitalized interest traps, finance lease interest, floating-rate sensitivity, Harbor Pacific 39→9% earnings-quality refactor, decision table vs coverage alone, pitfalls, and checklist.
• Interest expense ratio explained: formula, revenue drag and leverage signal Financing cost per revenue dollar — interest expense ÷ revenue formula, operating-to-pretax bridge, inverse link to coverage, floating-rate stress, sector benchmarks, Harbor Industrial 7.2%→4.1% pretax cliff refactor, decision table vs coverage alone, pitfalls, and checklist.
• Income before taxes explained: pretax earnings (EBT), income statement bridge and investor analysis Pretax income after operations and financing — EBIT-to-EBT bridge, non-operating items, adjusted EBT, cash vs reported rebuild, Harbor Global 43→8% earnings-quality refactor, decision table vs EBIT or net income alone, pitfalls, and checklist.
• Non-operating income and other income (expense) explained: GAAP presentation, earnings quality and the EBT bridge Below-EBIT distortion lines — FX translation and equity-method traps, pension and asset-sale credits, cash vs reported rebuild, Harbor Pacific 37→7% earnings-quality refactor, decision table vs EBIT alone, pitfalls, and checklist.
• Income tax expense and provision for income taxes explained: current vs deferred, EBT-to-net-income bridge and cash tax reconciliation ASC 740 provision mechanics — current and deferred components, rate reconciliation footnotes, valuation allowances and discrete items, cash vs reported tax, Harbor Digital 38→9% earnings-quality refactor, decision table vs ETR alone, pitfalls, and checklist.
• Net income explained: GAAP bottom line, attributable earnings and the EBT-to-equity bridge Income statement bottom line — continuing vs discontinued ops, NCI carve-out, GAAP vs adjusted earnings, CFO conversion and retained earnings link, Harbor Consumer 42→8% earnings-quality refactor, decision table vs EPS alone, pitfalls, and checklist.
• Fixed charge coverage ratio explained: EBIT, leases and total debt service Whether earnings cover all fixed financing obligations — EBIT and EBITDAR formulas, lease and preferred inclusions, covenant bands, Harbor Hospitality 1.8→2.9× refactor, decision table vs interest coverage, pitfalls, and checklist.
• Net debt to EBITDA ratio explained: leverage, covenant bands and credit risk Balance-sheet leverage in years of EBITDA — net debt formula, covenant and rating bands, sector benchmarks, LBO paydown math, Harbor Telecom 5.1→3.3× refactor, technique decision table vs interest coverage and EV/EBITDA, pitfalls, and checklist.
• Cash flow to debt ratio explained: CFO deleveraging power, covenant bands and credit red flags Operating cash flow versus total debt — CFO and FCF variants, rating bands, sector benchmarks, Harbor Manufacturing 0.09→0.28 refactor, decision table vs interest coverage alone, pitfalls, and checklist.
• Debt service coverage ratio (DSCR) explained: NOI, principal amortization and lender covenants Cash flow versus total debt service — NOI, EBITDA and CFADS variants, P&I in the denominator, covenant floors by asset class, Harbor Properties 1.12→1.48× refactor, decision table vs interest coverage alone, pitfalls, and checklist.
• Loan-to-value ratio (LTV) explained: CRE leverage, appraisal cushion and refinance gates Debt relative to collateral value — as-is vs stabilized appraisal bases, lender maximums by property type, LTV vs debt yield and DSCR, Harbor Properties 58%→78% refi cliff refactor, decision table vs debt yield alone, pitfalls, and checklist.
• Debt yield explained: NOI cushion, lender floors and CRE underwriting Income relative to loan balance — rate-independent underwriting metric, origination vs trailing tests, property-type floors, Harbor Logistics 9.0%→6.6% cash-trap refactor, decision table vs DSCR and LTV, pitfalls, and checklist.
• Property, plant and equipment (PP&E) explained: gross vs net assets, roll-forward and capitalization rules Tangible fixed assets on the balance sheet — gross vs net PP&E, accumulated depreciation, roll-forward to CapEx and D&A, capitalize vs expense repairs, impairment and disposals, Harbor Logistics 37→9% screen miss refactor, decision table vs EBITDA alone, pitfalls, and checklist.
• Capital expenditures (CapEx) explained: maintenance vs growth spending, intensity ratios and FCF Cash reinvestment in long-lived assets — PP&E roll-forward, maintenance vs growth capex splits, capex/revenue and capex/depreciation ratios, capitalized software traps, Harbor Manufacturing DCF refactor, technique decision table vs OpEx and leasing, pitfalls, and checklist.
• Capital intensity ratio explained: capex-to-revenue, asset turnover and reinvestment burden How much capital each revenue dollar requires — capex/revenue and PP&E intensity, maintenance vs growth splits, lease and capitalization adjustments, Harbor Datacenter 4→19% true intensity refactor, decision table vs margin alone, pitfalls, and checklist.
• Depreciation and amortization expense explained: PP&E methods, D&A add-backs and the cash flow bridge Non-cash expense matching capital to revenue — straight-line vs accelerated depreciation, PP&E roll-forward, CapEx ÷ D&A screens, EBITDA add-back limits, Harbor Manufacturing 34→11% FCF gap refactor, decision table vs EBITDA alone, pitfalls, and checklist.
• Free cash flow explained: operating cash, capex, FCF yield and owner earnings Cash a business actually generates after capital spending — CFO minus capex, maintenance vs growth investment, levered vs unlevered FCF, SBC adjustments, FCF yield vs P/E, negative FCF contexts, red flags, and a valuation checklist.
• Free cash flow yield explained: FCF/EV screening, forward yield and value investing Cash return on enterprise value — trailing vs forward FCF/EV, sector benchmarks, SBC and capex normalization, Harbor Capital value sleeve refactor, technique decision table vs P/E and dividend yield, pitfalls, and checklist.
• Free cash flow conversion rate explained: formula, earnings quality benchmarks and cash margin analysis How much reported profit becomes real cash — FCF ÷ net income and FCF ÷ EBITDA formulas, working capital and capex bridges, Harbor Digital 112%→38% quality refactor, decision table vs net margin alone, pitfalls, and checklist.
• Earnings yield explained: E/P ratio, equity risk premium and value screening Profit return on share price — trailing vs forward E/P as inverse P/E, bond yield and ERP comparison, FCF yield cross-check, Harbor Capital 34→9% value-trap refactor, decision table vs P/E alone, pitfalls, and checklist.
• Revenue growth rate explained: YoY, organic vs inorganic and quality screening Top-line expansion measurement — YoY vs QoQ annualized, organic vs acquisition-driven growth, constant currency and same-store sales, Harbor Retail 28→11% quality-growth refactor, decision table vs margin alone, pitfalls, and checklist.
• Sustainable growth rate explained: ROE, retention ratio and self-funded expansion Maximum growth without new capital — SGR = ROE × retention, DuPont drivers, internal vs debt/dilution funding, Harbor Consumer 31→9% unsustainable compounder refactor, decision table vs headline growth alone, pitfalls, and checklist.
• Invested capital explained: operating vs financing approach, ROIC denominator and normalization Operating asset base funded by all providers — operating and financing approach formulas, goodwill and lease adjustments, invested capital vs capital employed and book equity, ROIC and EVA denominators, Harbor Semiconductor 18→9% ROIC denominator refactor, decision table vs total assets, pitfalls, and checklist.
• Return on capital employed (ROCE) explained: NOPAT, capital base and value creation Operating return on all employed capital — ROCE = NOPAT ÷ capital employed, ROCE vs ROE vs ROIC, WACC spread tests, Harbor Industrial 24% ROE vs 9% ROCE trap / 27→8% value-destructive refactor, decision table vs margin alone, pitfalls, and checklist.
• NOPAT explained: net operating profit after tax, unlevered earnings and capital return inputs Operating profit after tax before financing — EBIT × (1 − tax rate) formula, tax rate normalization, NOPAT vs net income and EBITDA, ROCE/ROIC/EVA inputs, Harbor Industrial 18%→11% NOPAT margin refactor, decision table vs EBIT alone, pitfalls, and checklist.
• Effective tax rate explained: statutory vs cash tax, NOPAT normalization and earnings quality Book vs cash vs normalized ETR — operating tax on EBIT, tax shields and double-count traps, sector patterns, Harbor Pharma 12%→24% normalized rate refactor, decision table vs headline ETR, pitfalls, and checklist.
• EBIT explained: earnings before interest and taxes, operating profit and the income statement bridge Core operating profit before financing — revenue-to-EBIT formula paths, EBIT vs operating income and EBITDA, margin stack position, interest coverage and NOPAT bridge, Harbor Manufacturing 9.2%→5.8% normalized EBIT margin refactor, decision table vs net income alone, pitfalls, and checklist.
• Stock-based compensation (SBC) explained: RSUs, ASC 718 expense and dilution Equity pay through GAAP earnings — RSU and option grant mechanics, ASC 718 fair-value amortization, non-GAAP add-back debate, diluted share treasury stock method, Harbor Cloud 19% SBC/revenue refactor, technique decision table vs cash pay and buybacks, pitfalls, and checklist.
• Stock buybacks explained: share repurchases, EPS impact and capital allocation How companies retire their own shares — open market vs tender offers, EPS and share-count math, buybacks vs dividends, when repurchases create or destroy value, debt-funded traps, sector patterns, and an investor checklist.
• Shareholders’ equity explained: common stock, APIC, retained earnings and the equity roll-forward The owners’ residual claim on net assets — par value, additional paid-in capital, retained earnings, AOCI, treasury stock, book value per share, Harbor Software 31→8% leverage-screen miss refactor, decision table vs market cap alone, pitfalls, and checklist.
• Treasury stock explained: contra-equity accounting, buybacks and share count Repurchased shares held on the balance sheet — cost method journal entries, retired vs held shares, reissuance for SBC, EPS and book value impact, Harbor Software 38→7% buyback-accretion miss refactor, decision table, pitfalls, and checklist.
• Retained earnings explained: equity roll-forward, dividends, buybacks and book value Cumulative net income minus dividends on the balance sheet — roll-forward formula, retention ratio, negative retained earnings (accumulated deficit), buybacks vs dividend impact on equity, Harbor Retail 41→9% payout-sustainability refactor, decision table, pitfalls, and checklist.
• Comprehensive income and other comprehensive income (OCI) explained: AOCI, equity roll-forward and reclassification Net income plus OCI bridge — FX translation, unrealized securities and pension adjustments, AOCI roll-forward in shareholders’ equity, reclassification to net income, Harbor Insurance 44→9% book-value screen miss refactor, decision table vs net income alone, pitfalls, and checklist.
• Dividend yield explained: trailing vs forward yield, payout ratio and yield traps Income screening fundamentals — TTM vs forward yield formulas, earnings and FCF payout ratios, special-dividend distortion, Harbor Utilities income sleeve refactor, technique decision table vs buybacks and FCF yield, pitfalls, and checklist.
• Secondary offering explained: follow-on equity, dilution and shelf registrations Public follow-on raises after the IPO — primary vs secondary shares, shelf S-3 and overnight deals, ATM programs, greenshoe mechanics, Harbor Biotech dilution walkthrough, technique decision table vs buybacks and debt, pitfalls, and checklist.
• Registered direct offering explained: shelf RDOs, placement discounts and dilution Fast primary equity placements off Form S-3 shelves — placement-agent pricing, typical 3–7% discounts, warrant coverage, same-day closing, Harbor MedTech RDO case, decision table vs overnight follow-ons and PIPEs, pitfalls, and checklist.
• Rights offering explained: preemptive rights, subscription price and dilution math Shareholder subscription rights — record and ex-rights dates, subscription ratio and discount, oversubscription privileges, standby backstop fees, Harbor Biotech partial take-up case, technique decision table vs follow-ons and ATMs, pitfalls, and checklist.
• PIPE explained: private investment in public equity, discounts and dilution Negotiated public-company placements — registered direct vs unregistered PIPEs, pricing discounts, warrant coverage and reset clauses, resale registration timing, Harbor Diagnostics $85M case, technique decision table vs follow-ons and convertibles, pitfalls, and checklist.
• Equity warrant coverage explained: exercise price, reset clauses and dilution math PIPE and mezzanine equity sweeteners — coverage ratios, exercise terms, full-ratchet vs weighted-average resets, cashless exercise, Black-Scholes dilution modeling, Harbor Diagnostics 14.8→26.1% FD case, technique decision table vs convertibles and stock options, pitfalls, and checklist.
• Cost of goods sold (COGS) explained: direct costs, inventory accounting and the gross profit bridge Income statement direct costs — COGS by business model, FIFO/LIFO inventory bridge, COGS-to-revenue screens, classification red flags, Harbor Apparel 38%→29% restatement refactor, decision table vs gross margin alone, pitfalls, and checklist.
• Inventory explained: balance sheet classification, cost flow methods and obsolescence write-downs Current asset that is not cash — raw materials, WIP and finished goods, FIFO/LIFO/weighted-average cost flow, LCNRV reserves, roll-forward to COGS, Harbor Wholesale 43→9% valuation-screen miss refactor, decision table vs DIO alone, pitfalls, and checklist.
• Gross margin explained: gross profit, COGS and profitability analysis The first profitability line on the income statement — revenue minus cost of goods sold, gross margin percentage, industry benchmarks, margin trends, pricing power signals, SaaS vs retail COGS, red flags, and an investor checklist.
• Operating expense ratio explained: OpEx/revenue formula, SG&A benchmarks and margin stack analysis Overhead per revenue dollar — OpEx ÷ revenue formula, SG&A and R&D decomposition, gross-to-operating margin bridge, operating leverage links, Harbor Digital 38%→22% efficiency refactor, decision table vs operating margin alone, pitfalls, and checklist.
• Research and development (R&D) expense explained: capitalization, income statement placement and investor analysis Innovation spend on the income statement — ASC 730 expense vs ASC 350 capitalize rules, margin stack placement, cash vs reported R&D, SBC overlap, Harbor Biotech 44→9% earnings-quality refactor, decision table vs R&D intensity alone, pitfalls, and checklist.
• R&D intensity ratio explained: formula, capitalization traps and innovation ROI analysis Innovation spend per revenue dollar — R&D ÷ revenue formula, cash vs reported R&D, margin stack position, sector benchmarks, Harbor Pharma 41%→28% pipeline ROI refactor, decision table vs total OpEx ratio, pitfalls, and checklist.
• Selling, general and administrative (SG&A) expense explained: income statement placement, cost classification and investor analysis Commercial and corporate overhead on the income statement — selling vs G&A decomposition, margin stack placement, cash vs reported SG&A, restructuring and SBC traps, Harbor Retail 41→8% earnings-quality refactor, decision table vs SG&A intensity alone, pitfalls, and checklist.
• SG&A intensity ratio explained: formula, sales efficiency benchmarks and margin stack analysis Commercial overhead per revenue dollar — SG&A ÷ revenue formula, sales vs G&A decomposition, cash vs reported SG&A, Harbor Cloud 48%→31% sales-efficiency refactor, decision table vs total OpEx ratio, pitfalls, and checklist.
• Contribution margin explained: variable costs, unit economics and break-even analysis Per-unit profit after variable costs — CM vs gross and operating margin, variable vs fixed classification, break-even volume and margin of safety, SKU and channel mix decisions, Harbor Foods negative-CM SKU refactor, technique decision table vs GAAP margins alone, pitfalls, and checklist.
• Operating margin explained: formula, benchmarks and profitability analysis Core business profitability after COGS and operating expenses — operating income formula, GAAP vs adjusted margins, sector benchmark bands, gross vs net margin comparison, operating leverage links, red flags, worked example, and an investor checklist.
• Pretax profit margin explained: EBT formula, margin stack and tax-neutral profitability Earnings before tax per revenue dollar — pretax margin formula, operating-to-pretax interest drag vs pretax-to-net tax drag, adjusted EBT, sector benchmarks, Harbor Retail 8.4%→3.1% net cliff refactor, decision table vs operating margin alone, pitfalls, and checklist.
• Net profit margin explained: formula, bottom-line benchmarks and margin stack analysis Bottom-line profitability per revenue dollar — net income formula, gross vs operating vs net margin waterfall, interest and tax gap drivers, GAAP vs adjusted net margin, Harbor Manufacturing 11%→1.8% leverage trap refactor, decision table vs operating margin alone, pitfalls, and checklist.
• EBITDA margin explained: formula, benchmarks and cash-conversion analysis Operating cash proxy per revenue dollar — EBITDA margin formula, margin stack position vs operating and FCF margin, adjusted EBITDA skepticism, capex intensity gates, Harbor Telecom 28%→6% conversion trap refactor, decision table vs operating margin alone, pitfalls, and checklist.
• Operating cash flow explained: CFO formula, indirect method bridge and cash statement analysis Cash from core operations — indirect method bridge from net income, working capital and non-cash adjustments, CFO vs EBITDA and FCF, Harbor Manufacturing $48M accrual gap refactor, decision table vs net income alone, pitfalls, and checklist.
• Operating cash flow margin explained: CFO/revenue formula, earnings quality and margin stack Cash profitability per revenue dollar — OCF margin formula, margin stack vs net and EBITDA, working capital effects, CFO/net income conversion, Harbor Retail 11%→4% quality trap refactor, decision table vs net margin alone, pitfalls, and checklist.
• Inventory turnover ratio explained: formula, days on hand and sector benchmarks How fast a company sells and replaces stock — COGS over average inventory, days inventory outstanding, cash conversion cycle links, gross margin tradeoffs, LIFO/FIFO traps, red flags, and an investor checklist.
• Operating leverage explained: fixed costs, break-even and earnings sensitivity How fixed vs variable cost structure amplifies profit swings — break-even analysis, degree of operating leverage (DOL), high vs low leverage industries, cyclical risk, measuring leverage from 10-K filings, and an investor checklist.
• Degree of financial leverage (DFL) explained: interest sensitivity, EPS amplification and combined leverage How fixed interest magnifies EPS swings relative to EBIT — DFL formula, DOL × DFL combined leverage, rate stress tests, Harbor Media 4.8→2.1× refactor, technique decision table vs debt-to-equity alone, pitfalls, and 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.
• Shiller CAPE ratio explained: cyclically adjusted P/E, long-term valuation and expected returns 10-year inflation-adjusted earnings average, CAPE vs trailing and forward P/E, historical return predictability, international CAPE, Harbor Capital glide-path worked example, metric decision table, pitfalls, and investor checklist.
• PEG ratio explained: price/earnings-to-growth, Peter Lynch and fair value Adjust P/E for EPS growth — formula and Lynch's 1.0 rule, trailing vs forward growth rates, Rule of 40 for SaaS, cyclical and negative-earnings traps, sector PEG bands, PEG vs DCF, and a growth valuation checklist.
• Diluted EPS and earnings per share explained: basic vs diluted, treasury stock method and dilution Per-share profit measurement — basic and diluted EPS formulas, treasury stock and if-converted methods, RSU and convertible overhang, Harbor Analytics $1.20→$0.78 diluted refactor, decision table vs adjusted EPS, pitfalls, and checklist.
• Price-to-book ratio explained: book value, P/B valuation and value traps Shareholders' equity per share, tangible book value for banks, the P/B and ROE linkage, when P/B fits financials vs misleads tech, sector benchmarks, goodwill traps, and a value-investing checklist.
• Earnings quality explained: accruals, cash conversion and accounting red flags Whether reported profit is real — accrual vs cash earnings, CFO-to-net-income conversion, Sloan accrual ratio, revenue recognition traps, non-GAAP games, working capital manipulation, sector pitfalls, and an investor checklist.
• Adjusted EBITDA and non-GAAP metrics explained: add-backs, Reg G reconciliation and investor skepticism Management-adjusted profitability — EBITDA bridge, common SBC and restructuring add-backs, SEC Reg G rules, EBITDA vs free cash flow, Harbor Logistics 18→31% margin refactor, technique decision table vs GAAP operating income, pitfalls, and checklist.
• Net operating loss (NOL) carryforwards explained: deferred tax assets, Section 382 limits and valuation Tax loss carryforwards — NOL creation and absorption, DTA and valuation allowances, post-TCJA 80% caps, Section 382 ownership-change haircuts, Harbor Biotech DCF refactor, technique decision table vs cash taxes, pitfalls, and checklist.
• Deferred tax assets and liabilities explained: book-tax differences, DTA/DTL roll-forward and cash taxes Temporary vs permanent book-tax gaps — DTA and DTL sources, roll-forward and valuation allowances, cash tax vs GAAP tax expense bridge, Harbor Industrial 38→11% FCF tax drag refactor, decision table vs ETR alone, pitfalls, and checklist.
• Earnings per share (EPS) explained: basic vs diluted, GAAP vs adjusted and quality of earnings How EPS is calculated from the income statement, trailing vs forward EPS, GAAP vs non-GAAP adjustments, buyback impact on per-share math, quality-of-earnings red flags, and how EPS feeds the P/E ratio.
• DuPont analysis explained: ROE decomposition, three-factor and five-factor models Decompose return on equity into profit margin, asset turnover and financial leverage — three-factor and five-factor formulas, sector interpretation, Harbor Retail 22% ROE leverage trap refactor, decision table vs ROIC, pitfalls, and investor checklist.
• Asset turnover ratio explained: formula, sector benchmarks and DuPont link Revenue per dollar of total assets — total, fixed-asset and working-capital turnover variants, sector benchmark bands, Harbor Distributors 1.2→1.8× ROA refactor, decision table vs inventory turnover, pitfalls, and investor checklist.
• Equity multiplier explained: financial leverage, assets-to-equity formula and ROE amplification How many dollars of assets sit behind each dollar of book equity — DuPont ROE link, D/E conversion, sector benchmark bands, Harbor Infrastructure 4.5→1.9× refactor, decision table vs debt-to-equity alone, pitfalls, and investor checklist.
• Return on assets (ROA) explained: formula, DuPont link and asset efficiency Profit per dollar of total assets — ROA formula, net margin times asset turnover, ROA vs ROE vs ROIC, sector benchmarks, goodwill and cash distortions, bank ROA norms, decision table, and an investor checklist.
• Return on equity (ROE) and ROIC explained: DuPont analysis, capital efficiency and quality of returns How ROE and return on invested capital measure profitability — DuPont decomposition into margin, turnover and leverage, ROIC vs WACC, high-ROE traps, industry benchmarks, capital allocation, and a fundamental analysis checklist.
• Economic value added (EVA) explained: NOPAT, capital charge and economic profit Dollar-based value creation — NOPAT minus WACC capital charge, invested capital and lease adjustments, EVA spread vs ROIC, Harbor Logistics $39M→$22M EVA refactor, technique decision table vs accounting profit, pitfalls, and checklist.
• Net present value and IRR explained: discounting, hurdle rates and capital budgeting Time value of money, NPV and IRR formulas, hurdle rates vs WACC, mutually exclusive projects, Harbor warehouse automation worked example, method decision table, pitfalls, and checklist.
• Discounted cash flow (DCF) valuation explained: free cash flow, WACC and intrinsic value Project unlevered free cash flow, discount at WACC, terminal value with Gordon growth or exit multiples, sensitivity tables, margin of safety, common modeling mistakes, and when DCF beats shortcut multiples.
• Terminal value in DCF valuation explained: Gordon growth, exit multiples and sensitivity TV as 60–80% of enterprise value — Gordon perpetuity, exit-multiple cross-checks, H-model fade periods, TV% red flags, Harbor Software 72% TV overvaluation refactor, decision table vs explicit extension, pitfalls, and checklist.
• Dividend discount model explained: Gordon growth, multi-stage DDM and intrinsic value Equity-income valuation — Gordon growth and two-stage DDM, sustainable g from ROE and retention, CAPM required return, Harbor Utilities income sleeve refactor, technique decision table vs DCF and P/E, pitfalls, and checklist.
• Enterprise value explained: EV formula, net debt and valuation multiples Market cap plus net debt — why EV beats equity value for leveraged comparisons, EV/EBITDA and EV/Revenue, the equity bridge from DCF, M&A intuition, sector pitfalls (banks, REITs, cash piles), and an investor checklist.
• EBITDA explained: formula, adjusted EBITDA, margins and valuation use Earnings before interest, taxes, depreciation and amortization — bottom-up formula, what EBITDA includes and excludes, adjusted EBITDA skepticism, margin analysis, EV/EBITDA and leverage context, capex traps, sector patterns, worked example, and an investor checklist.
• EV/EBITDA ratio explained: enterprise value multiples, sector benchmarks and valuation traps The M&A workhorse multiple — EV formula, EBITDA normalization and SBC add-backs, sector benchmark table, EV/EBITDA vs P/E and EV/FCF, LBO paydown intuition, when the ratio breaks (banks, REITs, negative EBITDA), and an investor checklist.
• Comparable company analysis explained: trading comps, peer selection and valuation multiples Relative valuation from public peers — business-model screening, EBITDA and EV normalization, median vs mean statistics, LTM vs NTM alignment, Harbor Analytics 18.2→11.4× implied EV/EBITDA refactor, technique decision table vs DCF and precedent transactions, pitfalls, and checklist.
• Precedent transaction analysis explained: M&A comps, control premiums and deal multiples Relative valuation from completed deals — transaction screening, announced vs closed multiples, synergy stripping, control premium context, Harbor Packaging 14.2→9.8× LBO entry refactor, technique decision table vs trading comps and DCF, pitfalls, and checklist.
• Price-to-sales ratio explained: P/S valuation, EV/Revenue and growth stock multiples Revenue multiples when P/E fails — P/S and EV/Revenue formulas, gross margin context, sector benchmark bands, Rule of 40 SaaS links, cyclical and accounting traps, triangulation with other multiples, and an investor checklist.
• WACC explained: weighted average cost of capital, CAPM and discount rates The blended return equity and debt investors demand — cost of equity via CAPM, after-tax cost of debt, capital structure weights, unlevered beta, WACC in DCF models, ROIC hurdle rates, sector adjustments, and a valuation checklist.
• 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.
• Altman Z-score explained: distress zones, bankruptcy prediction and credit screening Edward Altman's composite distress model — original Z, Z-prime and Z-double-prime formulas, safe/grey/distress zones, Harbor Plastics covenant breach refactor, decision table vs interest coverage and Piotroski F-score, pitfalls, and checklist.
• Beneish M-score explained: earnings manipulation detection and forensic screening Messod Beneish's eight-variable manipulation model — DSRI, GMI, AQI, SGI, DEPI, SGAI, LVGI and TATA, probability thresholds, Harbor Retail 31→4% restatement refactor, decision table vs Sloan accruals and Piotroski F-score, pitfalls, and checklist.
• Sloan accrual ratio explained: accrual anomaly, earnings persistence and quality screening Richard Sloan's accrual anomaly — cash-flow and balance-sheet formulas, decile sorts, Harbor Software 24→5% earnings-surprise miss refactor, decision table vs Beneish M-score and FCF conversion, pitfalls, and checklist.
• Piotroski F-score explained: nine-point value stock quality screen Joseph Piotroski's binary fundamental checklist for cheap stocks — profitability, leverage, liquidity and efficiency signals, scoring bands, Harbor Capital deep-value screen refactor, comparison to quality factors, pitfalls, and checklist.
• 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.
• Margin of safety explained: intrinsic value, discounts and position sizing Graham's valuation buffer — quantifying discount to intrinsic value, DCF sensitivity tables, quality vs deep value thresholds, cyclical pitfalls, reverse DCF, position sizing links, and an investor 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.
• Hedge funds explained: strategies, fees, liquidity and who should invest Private alternative partnerships — long/short equity to global macro strategy families, 2-and-20 fee math, lock-ups and gates, performance measurement, Harbor Meridian worked example, vehicle decision table, pitfalls, and allocator checklist.
• Private equity explained: buyouts, fund structure, returns and who should invest Ownership investing in private companies — LBO and growth equity strategies, GP/LP structure, capital calls and the J-curve, IRR vs MOIC vs DPI, carried interest, Harbor Manufacturing buyout worked example, vehicle decision table, pitfalls, and allocator checklist.
• Leveraged buyout (LBO) explained: debt structure, value creation and sponsor returns How LBOs fund acquisitions with leverage — sources and uses, senior and subordinated debt stacks, EBITDA multiples, deleveraging and multiple expansion, IRR and MOIC math, Harbor Manufacturing sponsor model, technique decision table vs growth equity and strategic M&A, pitfalls, and checklist.
• Mezzanine financing explained: subordinated debt, PIK coupons and equity kickers The middle layer of LBO capital stacks — subordinated notes, cash and PIK interest, warrant kickers, intercreditor agreements, Harbor Manufacturing refinance model, technique decision table vs high-yield bonds and preferred equity, pitfalls, and checklist.
• Revolving credit facility explained: commitments, borrowing base and covenant headroom Senior secured liquidity lines — draw and repay mechanics, ABL borrowing-base formulas vs covenant-lite cash-flow revolvers, springing covenants, pricing grids, Harbor Retail $150M commitment vs $18M effective availability case, technique decision table vs term loans and factoring, pitfalls, and checklist.
• Asset-based lending explained: borrowing bases, advance rates and collateral monitoring Collateral-driven senior credit — receivables and inventory advance rates, eligibility haircuts and concentration caps, field exams and cash dominion, Harbor Distributors $32M overadvance case, technique decision table vs cash-flow revolvers and factoring, pitfalls, and checklist.
• Accounts receivable factoring explained: recourse vs non-recourse, advance rates and notification programs Invoice sale and assignment for same-day cash — recourse vs non-recourse structures, notification vs confidential programs, advance rates and discount fees, reserve holds and debtor credit limits, Harbor Logistics DSO 71→9 days case, technique decision table vs ABL and reverse factoring, pitfalls, and checklist.
• Letter of credit explained: documentary credits, UCP 600 and trade payment risk Bank-conditional import/export payment — sight vs usance, confirmed vs unconfirmed, UCP 600 strict compliance and discrepancy handling, standby LCs, Harbor Electronics $4.2M dispute refactor, technique decision table vs open account and SCF, pitfalls, and checklist.
• Documentary collection explained: D/P, D/A, URC 522 and trade payment risk Bank-mediated document exchange without payment guarantee — documents against payment vs acceptance, URC 522 protest rules, Harbor Steel $2.8M D/A default refactor, technique decision table vs LC and open account, pitfalls, and checklist.
• Purchase price allocation explained: goodwill, intangibles and M&A accounting Post-close ASC 805 fair-value allocation — identifiable intangibles vs goodwill, working capital true-ups, 338(h)(10) tax step-ups, Harbor Manufacturing LBO close model, technique decision table vs asset and stock deals, pitfalls, and checklist.
• Goodwill explained: acquisition premium, purchase price allocation and balance sheet analysis Residual M&A premium on the balance sheet — how goodwill arises in PPA, goodwill vs identifiable intangibles, tangible book value links, Harbor Systems 39→10% valuation-screen miss refactor, decision table vs P/B alone, pitfalls, and checklist.
• Goodwill impairment testing explained: ASC 350, reporting units and write-downs Annual goodwill impairment under ASC 350 — qualitative Step 0 vs quantitative fair value test, reporting units, DCF and multiple inputs, Harbor Retail $89M write-down refactor, technique decision table vs PPA and ROIC, pitfalls, and checklist.
• Intangible assets explained: capitalization, amortization, impairment and balance sheet analysis Finite vs indefinite-lived intangibles, capitalized software judgment, roll-forward and useful lives, impairment triggers, goodwill separation, Harbor Digital 41→12% earnings-quality refactor, decision table vs D&A alone, pitfalls, and checklist.
• M&A earnouts explained: contingent consideration, metric design and ASC 805 accounting Deferred purchase price tied to post-close performance — EBITDA and revenue metrics, probability-weighted fair value at close, quarterly remeasurement, Harbor Manufacturing $28M two-tier case, technique decision table vs upfront cash and escrow, pitfalls, and checklist.
• Corporate spin-off explained: sum-of-the-parts unlock, tax treatment and shareholder mechanics Division separations — pure spin vs split-off vs carve-out IPO, IRC Section 355 tax-free rules, distribution ratios and cost basis, stranded costs and debt allocation, Harbor Industrial logistics spin case, technique decision table vs asset sale, pitfalls, and checklist.
• Shareholder activism explained: activist campaigns, proxy fights and 13D filings How minority investors pressure boards — stake-building and Schedule 13D triggers, escalation from private letters to proxy contests, poison pills and settlements, Harbor Media spin-off and buyback case, technique decision table vs passive and merger arb, pitfalls, and checklist.
• Poison pill and shareholder rights plan explained: flip-in rights, triggers and hostile bid defense Board-adopted dilution defenses — flip-in vs flip-over mechanics, 15% trigger thresholds, dead-hand vs quick-redeem redemption, NOL and TSR pill variants, Harbor Defense hostile bid case, technique decision table vs staggered boards and white knights, pitfalls, and checklist.
• Tender offer explained: going private, self-tenders, proration and SEC rules Direct shareholder purchase bids — friendly vs hostile offers, going-private and issuer self-tenders, proration math on oversubscribed tranches, Schedule TO conditions and financing outs, Harbor Retail PE take-private case, technique decision table vs proxy merger, pitfalls, and checklist.
• Growth equity explained: minority growth capital, deal structure and sponsor returns Expansion-stage private financing between VC and buyouts — ARR and EBITDA entry criteria, preferred equity terms, board governance, value-creation playbooks, Harbor Analytics 3.1x MOIC model, technique decision table vs LBO and venture capital, pitfalls, and checklist.
• Burn rate and cash runway explained: gross vs net burn, scenario planning and fundraising triggers Startup survival metrics — gross vs net burn formulas, operating vs financing cash flow, scenario runway bands, fundraising trigger windows, Harbor Labs 9→22 month refactor, technique decision table vs ARR alone, pitfalls, and checklist.
• ARR (annual recurring revenue) explained: MRR annualization, waterfalls and SaaS valuation Top-line SaaS scale metric — ARR vs MRR, GAAP revenue and bookings, waterfall components, usage normalization, Harbor Cloud $18M→$31M refactor, technique decision table vs vanity growth, pitfalls, and checklist.
• Deferred revenue and ASC 606 explained: contract liabilities, SaaS recognition and cash timing Revenue recognition under ASC 606 — performance obligations, contract liabilities on the balance sheet, billings vs GAAP revenue bridge, Harbor Platform 54→19% growth refactor, technique decision table vs cash and ARR, pitfalls, and checklist.
• Accrued liabilities and accrued expenses explained: balance sheet accruals, cash timing and earnings quality Expense-before-cash obligations — payroll and bonus accruals, warranty and litigation reserves, indirect-method CFO add-backs, Harbor Services Q4 CFO gap refactor, technique decision table vs net income alone, pitfalls, and investor checklist.
• Contingent liabilities explained: ASC 450 recognition, litigation reserves and off-balance-sheet risk Probable vs possible loss contingencies — warranty and litigation accruals, guarantee disclosures, reserve roll-forward, probability-weighted EV overlay, Harbor MedTech 44→10% valuation refactor, decision table vs accrued reserves alone, pitfalls, and checklist.
• Net revenue retention (NRR) explained: SaaS cohort metrics, expansion and investor benchmarks Installed-base retention math — NRR vs GRR formulas, logo vs dollar churn, expansion and contraction buckets, cohort curves, Harbor Cloud 108→124% refactor, technique decision table vs ARR growth alone, pitfalls, and checklist.
• CAC payback period and SaaS sales efficiency metrics explained: magic number, burn multiple and LTV/CAC Acquisition efficiency math — gross-margin payback formulas, magic number and burn multiple bands, segment scaling gates, Harbor Cloud 31→17 month payback refactor, technique decision table vs Rule of 40 alone, pitfalls, and checklist.
• Venture capital explained: stages, fund structure, term sheets and power-law returns Startup equity financing from seed through growth — GP/LP structure, SAFEs and priced rounds, liquidation preference and dilution, power-law portfolio math, Harbor Labs seed-to-exit worked example, vehicle decision table, pitfalls, and founder or LP checklist.
• Venture debt explained: term loans, warrants and startup runway extension Senior secured loans for VC-backed startups — interest-only periods, warrant coverage, IP collateral, revenue covenants and cash sweeps, Harbor SaaS Series B 14→23 month runway case, technique decision table vs growth equity and SAFEs, pitfalls, and founder checklist.
• SAFE agreements explained: valuation caps, discounts and startup seed financing Y Combinator post-money SAFE mechanics — cap and discount better-of conversion, MFN and pro-rata side letters, stacking dilution, Harbor Labs Series A cap-table walkthrough, technique decision table vs convertible notes and priced seed, pitfalls, and founder checklist.
• Convertible notes explained: interest, maturity and startup seed financing Startup bridge debt mechanics — interest accrual and PIK, maturity extensions, cap and discount better-of conversion, qualified financing triggers, Harbor Analytics Series A dilution walkthrough, technique decision table vs SAFEs and priced seed, pitfalls, and founder checklist.
• Anti-dilution provisions explained: full ratchet, weighted average and down-round protection Preferred conversion price adjustments in down rounds — broad-based vs narrow-based weighted average, pay-to-play carve-outs, Harbor SaaS Series B recap 31% common dilution, technique decision table vs pro-rata rights, pitfalls, and checklist.
• Liquidation preference explained: participating preferred, seniority stacks and waterfall math 1x/2x multiples, participating vs non-participating preferred, pari passu seniority, conversion thresholds, Harbor Labs $180M acquisition waterfall model, technique decision table vs common-only cap tables, pitfalls, and checklist.
• International investing explained: global stocks, currency risk and portfolio allocation Developed vs emerging markets, home-country bias, hedged vs unhedged ETFs, ADRs, foreign tax credits, global index funds, and sizing international equity in a diversified portfolio.
• Emerging markets investing explained: growth, risk and portfolio allocation MSCI/FTSE classification, growth vs volatility trade-offs, currency and political risk, ETF and ADR access, Harbor Global Allocator EM tilt worked example, vehicle decision table, pitfalls, and checklist.
• ESG and sustainable investing explained: ratings, funds and greenwashing Environmental, social and governance pillars, ESG vs SRI vs impact, rating agencies and scores, ETF structures, performance debate, Harbor Endowment worked example, vehicle decision table, pitfalls, and checklist.
• Green bonds explained: use of proceeds, greenium, ICMA principles and portfolio role Labeled fixed income for environmental projects — ICMA Green Bond Principles, second-party opinions, green vs sustainability-linked bonds, greenium pricing debate, Harbor Endowment sleeve refactor, technique decision table vs IG corporates, pitfalls, and checklist.
• 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.
• ERC-4337 account abstraction explained: smart accounts, UserOps and paymasters Ethereum smart contract wallets without a hard fork — UserOperation bundles, EntryPoint validation, paymasters and session keys, Harbor Wallet onboarding refactor, technique decision table vs EOAs and MPC custody, pitfalls, and checklist.
• 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.
• Yield to maturity explained: YTM formula, current yield vs YTM and bond comparison IRR math for hold-to-maturity return, current yield vs YTM vs yield to call/worst, premium and discount pricing, Harbor Capital bond sleeve worked example, metric decision table, pitfalls, and investor checklist.
• Callable bonds explained: yield to call, negative convexity and reinvestment risk Call schedules and prices, YTC vs YTM vs yield to worst, negative convexity when rates fall, make-whole and extraordinary calls, Harbor Capital ladder refactor, technique decision table vs non-callables, pitfalls, and checklist.
• Floating-rate notes (FRNs) explained: SOFR reset, discount margin and rate-hike hedges Coupon reset mechanics, SOFR and T-bill benchmarks, quoted margin vs discount margin, low duration in rising rates, caps and floors, Harbor Capital cash sleeve refactor, technique decision table vs fixed bonds and TIPS, pitfalls, and checklist.
• Zero-coupon bonds explained: STRIPS, duration, phantom income and liability matching Discount pricing and implied yield, Treasury STRIPS mechanics, maximum duration for a given maturity, OID phantom income, LDI and education ladders, Harbor Capital pension overlay refactor, technique decision table vs T-bills and coupon bonds, pitfalls, and checklist.
• Bond duration and interest rate risk explained: modified duration, convexity and portfolio hedging Macaulay and modified duration, price-yield approximation, convexity and negative convexity on callables, effective duration for funds, portfolio immunization, Harbor Capital stress test, metric decision table, pitfalls, and investor checklist.
• Bond convexity explained: price curvature, duration gaps and callable negative convexity Convexity adjustment beyond duration, positive vs negative convexity on callables and MBS, immunization gaps, barbell vs bullet portfolios, Harbor Capital hedge refactor, technique decision table vs duration-only hedging, pitfalls, and checklist.
• Bond roll-down return explained: curve riding, carry decomposition and horizon attribution Static-curve price drift — aging down the term structure, carry plus roll-down plus curve-shift decomposition, steep vs inverted regimes, Harbor Capital bullet refactor, technique decision table vs barbell and immunization, pitfalls, and checklist.
• Key rate duration explained: partial durations, yield curve twist and bucket hedging Key rate and partial duration vectors, parallel vs twist scenarios, DV01 bucket hedging with futures and swaps, Harbor Capital curve-risk refactor, technique decision table vs modified duration only, pitfalls, and checklist.
• Bond portfolio immunization explained: duration matching, cash flow lock and rebalancing drift Fisher-Weil duration immunization, cash-flow dedication vs contingent immunization, convexity gaps, reinvestment drift, Harbor Capital pension sleeve refactor, technique decision table vs bond ladders and active management, pitfalls, and checklist.
• Credit spreads explained: corporate bond risk, IG vs HY and cycle signals Yield gaps over Treasuries — default and recovery pricing, OAS and spread duration, widening vs tightening cycles, recession signals, worked example, vehicle decision table, pitfalls, and checklist.
• TED spread explained: interbank credit stress, LIBOR vs T-bills and crisis signals 3-month unsecured funding minus T-bill yield — money-market credit premium, post-LIBOR Term SOFR proxies, 2008 and 2020 episodes, Harbor Capital liquidity desk refactor, technique decision table vs OAS and SOFR-OIS, pitfalls, and checklist.
• Credit rating agencies explained: Moody's, S&P, Fitch scales and fallen angels Big Three letter scales, issuer vs issue ratings and notching, outlook and watch signals, BBB-/BB+ cliff risk, Harbor Capital IG policy refactor, technique decision table vs CDS and spread models, pitfalls, and checklist.
• Sovereign bonds explained: government debt, DM vs EM credit and international fixed income Local vs hard-currency issuance, developed vs emerging market tiers, rating and spread drivers, FX hedging choices, Harbor Capital international sleeve refactor, technique decision table vs U.S. Treasuries and corporates, pitfalls, and checklist.
• Investment-grade corporate bonds explained: IG credit, spreads and portfolio role AAA to BBB- rating taxonomy, credit spread over Treasuries, duration vs default risk, sector and callable features, Harbor Capital core sleeve refactor, technique decision table vs HY and munis, pitfalls, and checklist.
• High-yield bonds (junk bonds) explained: ratings, spreads and default risk BB/B/CCC rating tiers, yield-to-worst and spread decomposition, default and recovery math, fallen angels and covenant-lite trends, Harbor Capital credit sleeve refactor, technique decision table vs IG and BDCs, pitfalls, and checklist.
• Senior bank loans and leveraged loans explained: SOFR float, first lien and covenant-lite risk First-lien senior secured structure, Term SOFR spreads and floors, covenant-lite and refinancing cycles, loan ETFs vs CLO tranches, Harbor Capital floating-rate sleeve refactor, technique decision table vs HY bonds and FRNs, pitfalls, and checklist.
• Total return swaps explained: synthetic exposure, financing legs and counterparty risk OTC total return swaps — payer vs receiver roles, equity and bond TRS cash flows, SOFR financing spreads, CSA collateral, synthetic longs without custody, Harbor Capital leveraged credit sleeve refactor, technique decision table vs repo and CDS, pitfalls, and checklist.
• Securities lending explained: stock borrow, loan fees, collateral and prime brokerage Temporary transfer of securities for collateral and fees — locate and recall mechanics, cash vs non-cash collateral, GC vs special loan rates, manufactured dividends, agent lenders and prime brokerage, Harbor Capital equity long-short refactor, technique decision table vs TRS and repo, pitfalls, and checklist.
• Securities margin financing explained: initial margin, maintenance calls and leverage Broker loans secured by portfolio holdings — Reg T 50% initial and FINRA 25% maintenance floors, buying power and SMA, margin calls and forced liquidation, portfolio margin vs Reg T, Harbor Capital tactical overlay refactor, technique decision table vs cash and futures, pitfalls, and checklist.
• Straddles and strangles explained: long vol, earnings trades and breakeven math Two-legged volatility structures — ATM straddles vs OTM strangles, long vs short payoff profiles, implied-move and breakeven formulas, earnings vol crush, Harbor Capital event overlay refactor, technique decision table vs iron condors and variance swaps, pitfalls, and checklist.
• Iron condors explained: defined-risk premium selling, wing width and management Four-legged short strangle with protective wings — max profit and loss math, delta-neutral strike selection, 50% profit and 21 DTE exits, Harbor Capital index carry refactor, technique decision table vs naked strangles and butterflies, pitfalls, and checklist.
• Protective puts explained: portfolio insurance, floor pricing and hedge sizing Long stock plus long put — payoff floors, premium and breakeven math, strike and DTE selection, puts vs stop-loss orders, Harbor Capital equity sleeve refactor, technique decision table vs covered calls and collars, pitfalls, and checklist.
• Collar options explained: zero-cost hedges, floor-ceiling payoffs and rolling Long stock plus long put plus short call — bounded payoff box, zero-cost collar math, strike width and DTE selection, roll and assignment rules, Harbor Capital concentrated-holding refactor, technique decision table vs protective puts and covered calls, pitfalls, and checklist.
• Gamma hedging explained: delta rebalancing, scalping and pin risk Options convexity management — long vs short gamma P&L, delta band rebalancing, gamma scalping for market makers, realized vs implied vol economics, pin risk near expiration, Harbor Capital earnings-week overlay refactor, technique decision table vs static hedges, pitfalls, and checklist.
• Variance swaps explained: realized vol payoffs, replication and dispersion trading OTC forwards on realized variance — payer vs receiver legs, log-return sampling and strike quoting, dealer replication with OTM strips, vol-of-vol convexity, Harbor Capital dispersion overlay refactor, technique decision table vs VIX and gamma hedging, pitfalls, and checklist.
• Option-adjusted spread (OAS) explained: callable bonds, MBS trees and relative value Spread after valuing embedded options — Z-spread vs OAS, binomial trees for callables and MBS, effective duration and convexity, Harbor Capital agency sleeve refactor, technique decision table vs ASW and I-spread, pitfalls, and checklist.
• Credit default swaps explained: CDS mechanics, index hedges and spread pricing Buy and sell credit risk like insurance on a reference issuer — protection buyer vs seller, spread as implied default probability, credit events and recovery auctions, CDX/iTraxx index hedges, CDS–cash basis, Harbor Capital HY sleeve refactor, technique decision table, pitfalls, and checklist.
• Repo markets explained: repurchase agreements, haircuts and short-term funding Sale-and-repurchase mechanics for overnight financing — collateral haircuts, GC vs special repo, tri-party clearing, Fed ON RRP and SRF, Harbor Capital cash sleeve refactor, technique decision table vs T-bills and MMFs, pitfalls, and checklist.
• SOFR explained: secured overnight financing rate, Term SOFR and LIBOR transition Volume-weighted overnight repo benchmark — tri-party and bilateral GC trades, secured vs unsecured spread dynamics, Term SOFR and compounded-in-arrears FRNs, SOFR-OIS curves, Harbor Capital floating-rate note refactor, technique decision table vs fed funds and T-bills, pitfalls, and checklist.
• SOFR futures explained: CME contracts, implied rates and short-rate hedging Exchange-traded SOFR hedges — 1-month and 3-month SR1/SR3 specs, price-to-rate conversion, cash settlement and convergence, strip and butterfly structures, convexity vs FRAs, Harbor Capital quarterly cash refactor, technique decision table vs swaps and OTC forwards, pitfalls, and checklist.
• SOFR-OIS spread explained: funding stress, bank liquidity and rate transmission Overnight secured vs unsecured funding premium — OIS construction post-LIBOR, reserve scarcity and quarter-end drivers, CP and stress dynamics, Harbor Capital liquidity desk refactor, technique decision table vs fed funds only, pitfalls, and checklist.
• Interest rate swaps explained: fixed-for-floating, DV01 and SOFR conventions Plain-vanilla IRS mechanics — notional and net settlement, swap curves and par rates, DV01 and key-rate risk, SOFR-OIS discounting and compounded-in-arrears floating legs, CSA collateral, Harbor Capital liability hedge refactor, technique decision table vs FRNs and futures, pitfalls, and checklist.
• Interest rate swap spread explained: swap curve vs Treasuries, credit and liquidity premia Swap spread mechanics — par swap rate minus same-maturity Treasury yield, LIBOR-to-SOFR transition effects, dealer balance-sheet constraints, negative swap spreads, Harbor Capital hedge tracking error refactor, technique decision table vs OIS and credit spreads, pitfalls, and checklist.
• Forward rate agreements explained: FRA notation, cash settlement and SOFR hedging OTC forward rate locks — t×T notation, borrower vs lender payoffs, advance settlement discounting, SOFR compounding alignment, Harbor Capital bridge-loan refactor, technique decision table vs swaps and caps, pitfalls, and checklist.
• Mortgage-backed securities explained: pass-throughs, prepayment and agency MBS Agency MBS securitization — pass-through coupons, WAC and WAM, CPR and PSA prepayment models, negative convexity and OAS, TBA trading and dollar rolls, Harbor Capital mortgage sleeve refactor, technique decision table vs Treasuries and REITs, pitfalls, and checklist.
• Collateralized loan obligations explained: CLO tranches, waterfalls and leveraged loans Leveraged loan securitization — CLO 2.0 tranche waterfalls, WARF and diversity scores, IC/OC coverage tests, reinvestment periods, CLO equity vs AAA debt, Harbor Capital floating-rate sleeve refactor, technique decision table vs HY bonds and CDS, pitfalls, and checklist.
• Index rebalancing explained: reconstitution calendars, price impact and portfolio turnover Benchmark membership and weight updates — Russell and S&P reconstitution calendars, index rebalance effect, front-running and index arbitrage, Harbor Capital sleeve refactor, technique decision table vs portfolio rebalancing, pitfalls, and checklist.
• Asset-backed securities explained: auto, card and consumer loan securitization Non-mortgage securitization — auto, credit card, student and equipment ABS pools, tranche waterfalls, credit enhancement and OC, early amortization triggers, Harbor Capital consumer sleeve refactor, technique decision table vs MBS and CLO, pitfalls, and checklist.
• Convertible bonds explained: conversion premium, bond floor and equity upside Hybrid debt-equity securities — conversion ratio and price, bond floor vs parity, issuer and investor motives, pricing sensitivity, vanilla to CoCo types, Harbor Tech worked example, vehicle decision table, pitfalls, and checklist.
• Preferred stock explained: dividends, priority, callable terms and income investing Equity with bond-like income — cumulative vs non-cumulative dividends, capital-structure seniority, callable and convertible features, yield to call, Harbor Utilities worked example, instrument decision table, pitfalls, and checklist.
• Municipal bonds explained: tax-free income, GO vs revenue bonds and muni funds State and local government debt — general obligation vs revenue structures, federal and state tax exemption, taxable-equivalent yield, credit and AMT traps, callable bonds, muni ETFs vs ladders, and a retail checklist.
• 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.
• U.S. Treasury auction explained: competitive bids, bid-to-cover and yield discovery Uniform-price auction mechanics — competitive vs non-competitive bids, bid-to-cover and tail vs when-issued, primary dealer and indirect shares, reopenings, Harbor Capital cash-sleeve refactor, technique decision table vs secondary-only access, pitfalls, and checklist.
• Primary dealer system explained: Treasury market making, Fed counterparties and auction plumbing NY Fed counterparty framework — dealer auction obligations, indirect bidder routing, when-issued and on-the-run liquidity, repo and SRF access, Harbor Capital execution refactor, technique decision table vs ETF-only access, pitfalls, and checklist.
• Standing Repo Facility explained: Fed SRF rate, repo ceiling and money-market plumbing Permanent Fed overnight repo backstop — SRF rate as secured funding ceiling, eligible primary dealers and tri-party banks, September 2019 stress context, ON RRP floor symmetry, Harbor Capital liquidity desk refactor, technique decision table vs discount window, pitfalls, and checklist.
• Overnight Reverse Repo Facility explained: ON RRP rate, Fed floor and MMF cash parking Standing Fed reverse repo floor — ON RRP award rate, eligible MMFs and GSEs, corridor symmetry with SRF ceiling, QT drain and reserve migration, Harbor Capital cash sleeve refactor, technique decision table vs T-bills, pitfalls, and checklist.
• Fed discount window explained: primary credit, stigma and bank liquidity backstop Direct Fed lending to banks — primary vs secondary credit, discount rate vs IORB penalty spread, borrowing stigma, March 2023 stress context, Harbor Credit Union liquidity desk refactor, technique decision table vs SRF and fed funds, pitfalls, and 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.
• Treasury notes (T-notes) explained: coupons, duration and intermediate allocation 2/3/5/7/10-year U.S. government notes — semiannual coupons, on-the-run liquidity, duration and yield-curve positioning, Harbor Capital intermediate sleeve refactor, technique decision table vs T-bills and corporates, pitfalls, and checklist.
• Treasury bonds (T-bonds) explained: long duration, convexity and pension-style allocation 20- and 30-year U.S. government bonds — semiannual coupons, convexity at the long end, term premium and liability matching, Harbor Capital long-duration sleeve refactor, technique decision table vs T-notes and STRIPS, pitfalls, and checklist.
• TIPS explained: Treasury Inflation-Protected Securities, real yields and breakeven inflation CPI-linked U.S. government bonds — principal adjustments, real yield vs nominal yield, breakeven inflation math, TreasuryDirect vs ETFs, phantom income tax traps, TIPS vs I Bonds, and a retail checklist.
• Inflation breakevens explained: TIPS spreads, forward rates and market-implied CPI Nominal minus real Treasury yields — 5y and 10y breakevens, 5y5y forward inflation, inflation swaps, liquidity and deflation-floor premia, Harbor Capital real-return sleeve refactor, technique decision table vs surveys and commodities, pitfalls, and checklist.
• Inflation swaps explained: zero-coupon and YoY structures, CPI legs and LDI hedging OTC inflation derivatives — payer vs receiver, ZCIS and YoY conventions, CPI lag and interpolation, swap–TIPS basis, Harbor Pension LDI refactor hedge 71→94%, technique decision table vs TIPS and breakevens, pitfalls, and checklist.
• Term premium explained: yield decomposition, ACM estimates and duration risk Expected short rates plus compensation for holding long bonds — ACM and survey estimates, inflation uncertainty and supply drivers, curve segments, Harbor Capital duration sleeve refactor, technique decision table vs curve trades and breakevens, pitfalls, and checklist.
• Liability-driven investing explained: duration matching, funding ratios and pension derisking Pension and insurance LDI — liability present value and discount curves, duration and cashflow immunization, derisking glidepaths, swap overlays, Harbor Capital pension sleeve refactor, technique decision table vs TAA and bond ladders, pitfalls, and checklist.
• Swaptions explained: payer and receiver options on interest rate swaps Options on swap rates — payer vs receiver, European and Bermudan exercise, Black and SABR volatility, annuity factors and DV01, Harbor Capital pension derisking overlay refactor, technique decision table vs caps and plain IRS, pitfalls, and checklist.
• Interest rate caps and floors explained: hedging floating-rate exposure Caplets and floorlets on SOFR — strike and notional schedules, collars and zero-cost structures, Black caplet vol surfaces, Harbor Capital corporate loan hedge refactor, technique decision table vs swaptions and plain IRS, pitfalls, and checklist.
• Cross-currency basis swaps explained: FX legs, basis spreads and funding arbitrage Dual-currency floating legs, initial and final notional exchange, basis spread over OIS, covered interest parity breaks, MTM resets and CSA, Harbor Capital EUR debt hedge refactor, technique decision table vs plain IRS and FX forwards, pitfalls, and checklist.
• Commercial paper explained: short-term corporate funding, ratings and MMF holdings Unsecured corporate IOUs from 1 to 270 days, discount yield math, A1/P1 ratings and backup lines, dealer vs direct programs, ABCP conduits, Harbor Capital cash sleeve refactor, technique decision table vs T-bills and repo, pitfalls, and checklist.
• Supply chain finance explained: reverse factoring, payables programs and working capital Buyer-initiated payables finance — approved invoice workflows, supplier early payment at anchor credit spreads, balance-sheet classification and disclosure, Harbor Manufacturing DPO 47→72 days and $38M liquidity, technique decision table vs dynamic discounting and commercial paper, pitfalls, and checklist.
• Certificate of deposit (CD) explained: APY, terms, penalties and CD ladders Bank time deposits — fixed APY and term lengths, FDIC insurance limits, traditional vs no-penalty and brokered CDs, early withdrawal penalty math, CD ladders vs T-bills and savings, tax treatment, and a retail cash checklist.
• High-yield savings accounts explained: APY, FDIC insurance and cash parking Federally insured variable-rate savings — APY vs APR, FDIC and NCUA limits, online banks vs brick-and-mortar, HYSA vs MMF vs CDs vs T-bills, teaser-rate traps, tax treatment, and a retail cash checklist.
• 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.
• Backdoor Roth IRA explained: pro-rata rule, Form 8606 and high-income Roth access Legal two-step Roth funding for earners above MAGI limits — non-deductible Traditional IRA contributions, Roth conversions, pro-rata tax traps, reverse rollovers, mega backdoor contrast, and an annual checklist.
• Roth conversion ladder explained: early retirement access, five-year rule and tax planning Multi-year Roth conversions to unlock pre-tax IRA dollars before 59½ — five-year seasoning, penalty-free principal withdrawals, bracket filling, ACA subsidy traps, RMD reduction, and an early-retirement 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.
• Social Security benefits explained: FRA, claiming ages and spousal rules Work credits, AIME and PIA calculation, full retirement age, early vs delayed claiming, spousal and survivor benefits, earnings test, benefit taxation, WEP/GPO, Medicare coordination, and a retirement planning checklist.
• Monte Carlo simulation for portfolio and retirement planning explained Stress-test retirement with thousands of random market paths — return distributions, inflation, withdrawal sequences, success probability, fat tails, correlation, sensitivity analysis, and a planning checklist beyond single average-return projections.
• Sequence of returns risk explained: withdrawals, bear markets and retirement math Why return order beats average return in decumulation — accumulation vs withdrawal asymmetry, the retirement red zone, safe withdrawal rates, bucket strategies, income layering, flexible spending guardrails, and a planning checklist.
• Safe withdrawal rate explained: the 4% rule, Trinity Study and retirement drawdown How much you can spend from a retirement portfolio each year — Bengen and Trinity Study origins, inflation-adjusted withdrawals, Guyton-Klinger guardrails, bucket strategies, Monte Carlo stress tests, tax-aware drawdown, worked example, and a planning checklist.
• Estate planning explained: wills, trusts, probate and beneficiary designations Wills vs revocable living trusts, probate avoidance and funding, beneficiary forms that override wills, durable POA, healthcare directives, step-up in basis, federal estate tax exemption, digital assets, and a family 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.
• WTI crude oil prices explained: benchmarks, supply-demand and macro signals West Texas Intermediate vs Brent, NYMEX futures and Cushing delivery, OPEC and shale supply, EIA weekly inventories, dollar and geopolitical risk, CPI and PPI pass-through, Harbor Energy weekly read worked example, indicator decision table, pitfalls, and checklist.
• EIA weekly petroleum status report explained: crude inventories, Cushing stocks and refinery runs Wednesday WPSR release mechanics — commercial crude and product builds/draws, Cushing hub stocks, gasoline and distillate, refinery utilization, imports/exports and SPR, API vs EIA divergence, Harbor Energy desk refactor, technique decision table vs headline-only reads, pitfalls, and checklist.
• Crack spread and refinery margins explained: 3-2-1 spreads, gasoline cracks and utilization signals Refinery margin economics — 3-2-1 and 5-3-2 crack formulas, RBOB and heating oil futures math, seasonal driving and distillate demand, WPSR utilization linkage, Harbor Energy margin desk refactor, technique decision table vs crude-only hedging, pitfalls, and checklist.
• Natural gas prices explained: Henry Hub, storage, LNG and utility bills Henry Hub vs regional basis, NYMEX futures and storage cycles, shale supply and LNG exports, EIA weekly storage reports, heating-degree days and power burn, CPI utilities pass-through, Harbor Energy winter read worked example, indicator decision table, pitfalls, and checklist.
• Uranium prices explained: U3O8 spot, term contracts and nuclear fuel U3O8 yellowcake spot vs long-term utility contracts, Kazatomprom and Cameco supply, conversion and enrichment SWU spreads, uncovered requirements and contracting cycles, SMR and data-center power narrative, Harbor Energy nuclear fuel monitor worked example, indicator decision table, pitfalls, and checklist.
• Baltic Dry Index explained: dry bulk freight rates, vessel classes and commodity shipping BDI index points and sub-indices (BCI, BPI, BSI, BHSI), Capesize through Handysize vessel classes, iron ore coal and grain tonne-miles, fleet supply and port congestion, freight share of CFR cost, Harbor Logistics freight monitor worked example, indicator decision table, pitfalls, and checklist.
• Rubber prices explained: TSR20 futures, tire demand and Southeast Asia supply SICOM TSR20 and TOCOM RSS3 benchmarks, USD cents per kg quoting, Thailand and Indonesia tapping and wintering seasons, auto and tire mill demand, synthetic rubber from butadiene, ANRPC supply reports, Harbor Industrial materials monitor worked example, indicator decision table, pitfalls, and checklist.
• Gold prices explained: spot, futures, central banks and real yields Spot vs COMEX futures and LBMA benchmarks, mining supply and jewelry demand, central bank reserve buying, real yields and dollar correlation, ETFs vs physical vs miners, safe-haven flows, Harbor Capital monthly read worked example, indicator decision table, pitfalls, and checklist.
• Silver prices explained: spot, futures, industrial demand and the gold ratio Spot vs COMEX SI futures and LBMA benchmarks, industrial fabrication and solar demand, investment and jewelry flows, gold/silver ratio, byproduct mine supply, SLV vs physical vs miners, Harbor Metals monthly read worked example, indicator decision table, pitfalls, and checklist.
• Platinum prices explained: spot, futures, auto catalysts and PGM supply NYMEX PL futures and LBMA benchmarks, South Africa and Russia supply concentration, auto catalytic converter demand, palladium substitution, hydrogen fuel-cell optionality, PPLT vs physical vs miners, Harbor Autos monthly read worked example, indicator decision table, pitfalls, and checklist.
• Palladium prices explained: spot, futures, gasoline catalysts and PGM volatility NYMEX PA futures and LBMA benchmarks, Russia and South Africa supply concentration, gasoline catalytic converter demand, platinum substitution cycles, PALL ETF vs physical, Harbor Autos PGM monitor worked example, indicator decision table, pitfalls, and checklist.
• Nickel prices explained: LME, stainless steel, EV batteries and Indonesia supply LME Class 1 vs NPI and ferronickel benchmarks, Indonesia laterite and export policy, stainless steel and NMC battery demand, SHFE/LME arbitrage, Harbor Industrial battery metals monitor worked example, indicator decision table, pitfalls, and checklist.
• Coffee prices explained: ICE arabica futures, Brazil frost risk and robusta spreads ICE Coffee C arabica benchmarks, cents per pound quoting, Brazil biennial harvest and frost risk, Vietnam robusta exports, arabica–robusta spread dynamics, ICO and USDA calendars, Harbor Ag soft commodities monitor worked example, indicator decision table, pitfalls, and checklist.
• Orange juice prices explained: FCOJ futures, Florida freeze risk and Brazil supply ICE FCOJ-A concentrate benchmarks, cents per pound solids quoting, Florida hurricane and freeze risk, citrus greening disease, Brazil São Paulo crop and export parity, NFC vs reconstituted demand, Harbor Ag soft commodities monitor worked example, indicator decision table, pitfalls, and checklist.
• Sugar prices explained: ICE world sugar futures, Brazil ethanol arbitrage and India export policy ICE No. 11 world raw sugar benchmarks, cents per pound quoting, Brazil cane sugar-vs-ethanol mix, India export quotas and bans, EU beet supply, ISO stocks-to-use, Harbor Ag soft commodities monitor worked example, indicator decision table, pitfalls, and checklist.
• Cocoa prices explained: ICE futures, West Africa supply and chocolate grindings ICE Cocoa C benchmarks, dollars per metric tonne quoting, Ivory Coast and Ghana farmgate policy and LID premiums, Harmattan weather and disease risk, quarterly grindings demand, EUDR traceability, Harbor Ag soft commodities monitor worked example, indicator decision table, pitfalls, and checklist.
• Tea prices explained: Mombasa auctions, Kenya exports and black vs green tea spreads Mombasa and Kolkata auction benchmarks in USD per kilogram, Kenya and India export cycles, CTC vs orthodox grade premiums, Pakistan and Egypt import demand, bubble-tea green tea growth, Harbor Ag soft commodities monitor worked example, indicator decision table, pitfalls, and checklist.
• Cotton prices explained: ICE futures, U.S. abandonment and textile mill demand ICE Cotton No. 2 benchmarks, cents per pound quoting, Texas High Plains drought and abandonment, China import quotas and state reserves, India MSP policy, USDA WASDE and NASS crop progress, polyester substitution, Harbor Ag fiber monitor worked example, indicator decision table, pitfalls, and checklist.
• Wool prices explained: AWEX EMI, micron grades and Australian export cycles AWEX Eastern Market Indicator in Australian cents per kg clean, merino micron fineness grades, Australia and New Zealand shearing seasons, China textile import demand, drought and flock liquidation, synthetic fiber competition, Harbor Ag fiber monitor worked example, indicator decision table, pitfalls, and checklist.
• Hay prices explained: alfalfa benchmarks, dairy demand and drought forage cycles U.S. alfalfa and grass hay per-ton benchmarks, RFV and protein quality grades, Western irrigation supply, dairy and beef feed demand, drought pasture substitution, USDA hay stocks reports, export corridors, Harbor Ag forage monitor worked example, indicator decision table, pitfalls, and checklist.
• Dairy prices explained: Class III milk, butter and cheese benchmarks CME Class III and Class IV milk futures, cents per hundredweight quoting, butter and cheese block benchmarks, component pricing, feed cost linkage to corn and hay, USDA Milk Production and Cold Storage reports, Harbor Ag dairy monitor worked example, indicator decision table, pitfalls, and checklist.
• Egg prices explained: shell egg benchmarks, layer flocks and avian flu USDA AMS shell egg benchmarks in cents per dozen, large white vs brown and cage-free premiums, layer flock cycles and HPAI depopulation, feed costs from corn and soybean meal, egg products for food manufacturing, Harbor Ag egg monitor worked example, indicator decision table, pitfalls, and checklist.
• Chicken prices explained: broiler benchmarks, parts markets and the poultry supply chain USDA AMS composite and parts benchmarks in cents per pound, hatch-to-slaughter pipeline, integrator economics, wing and breast spreads, corn and soybean meal feed costs, export demand, Harbor Ag poultry monitor worked example, indicator decision table, pitfalls, and checklist.
• Peanut prices explained: runner benchmarks, acreage cycles and food-oil demand U.S. farmer stock per-ton quoting, runner vs Virginia vs Spanish type spreads, Georgia and Southeast acreage rotation with cotton, peanut butter and snack demand, CCC loan stocks, Argentina export competition, Harbor Ag oilseed monitor worked example, indicator decision table, pitfalls, and checklist.
• Sunflower prices explained: MATIF benchmarks, Black Sea exports and EU crush demand Euronext MATIF sunflower seed futures, Black Sea FOB oil-type offers, oil vs confection striped premiums, Ukraine corridor risk, EU biodiesel policy, sunflower-palm spread, Harbor Ag oilseed monitor worked example, indicator decision table, pitfalls, and checklist.
• Rice prices explained: CBOT futures, Asian monsoons and export policy CBOT Rough Rice ZR benchmarks, cents per hundredweight quoting, Thai and Vietnamese 5% broken FOB export prices, India MSP and export bans, China state reserves, El Niño monsoon risk, USDA WASDE, Harbor Ag grain monitor worked example, indicator decision table, pitfalls, and checklist.
• Live cattle and beef prices explained: CME futures, herd cycles and boxed beef CME Live Cattle and Feeder Cattle benchmarks, cents per pound quoting, cow-calf-to-feedlot pipeline, multi-year herd cycle and drought liquidation, Cattle on Feed and boxed beef cutout, corn feed-cost linkage, Harbor Ag livestock monitor worked example, indicator decision table, pitfalls, and checklist.
• Lean hog prices explained: CME futures, the hog cycle and pork cutout CME Lean Hog HE benchmarks, cents per pound quoting, farrow-to-finish pipeline, Quarterly Hogs and Pigs inventory, pork cutout and belly primal spreads, corn and soybean meal feed costs, export demand, Harbor Ag livestock monitor worked example, indicator decision table, pitfalls, and checklist.
• Palm oil prices explained: BMD futures, biodiesel mandates and Southeast Asia supply Bursa Malaysia FCPO benchmarks, ringgit per tonne quoting, Indonesian CPO and Malaysian RBD olein FOB, biodiesel B20/B35 mandates, palm–soy oil spread, export levies and DMO policy, EUDR traceability, Harbor Ag soft commodities monitor worked example, indicator decision table, pitfalls, and checklist.
• Corn prices explained: CBOT futures, ethanol demand and feed economics Chicago ZC corn benchmarks, cents per bushel quoting, U.S. Corn Belt and Brazil safrinha supply, ethanol blending and livestock feed demand, USDA WASDE balance sheets, Harbor Ag grain monitor worked example, indicator decision table, pitfalls, and checklist.
• Soybean prices explained: CBOT futures, crush margins and China demand Chicago ZS soybean benchmarks, cents per bushel quoting, meal and oil crush spreads, Brazil and Argentina export cycles, China import demand, biodiesel policy, USDA WASDE balance sheets, Harbor Ag grain monitor worked example, indicator decision table, pitfalls, and checklist.
• Potash fertilizer prices explained: MOP, supply concentration and crop demand Muriate of potash and SOP benchmarks, Vancouver and Brazil CFR assessments, Canada and Belarus supply concentration, corn and soybean nutrient demand, NPK affordability spreads, Harbor Ag fertilizer monitor worked example, indicator decision table, pitfalls, and checklist.
• Wheat prices explained: CBOT futures, Black Sea supply and food inflation Chicago soft red winter, Kansas hard red winter and Minneapolis spring wheat benchmarks, cents per bushel quoting, Black Sea export corridors, USDA WASDE balance sheets, crop condition ratings, Harbor Ag grain monitor worked example, indicator decision table, pitfalls, and checklist.
• Barley prices explained: feed vs malt grades, MATIF benchmarks and beer demand Feed vs malting quality spreads, MATIF and ICE benchmarks, Russia and Australia export cycles, Saudi feed tenders, China malt policy, livestock feed substitution with corn and wheat, Harbor Ag grain monitor worked example, indicator decision table, pitfalls, and checklist.
• Oats prices explained: CBOT futures, oat milk demand and feed economics CBOT ZO futures and cash basis, milling vs feed grade spreads, Prairie and Australian supply, oat milk and cereal food demand, livestock feed substitution with corn and barley, Harbor Ag grain monitor worked example, indicator decision table, pitfalls, and checklist.
• Sorghum prices explained: China imports, ethanol feed and corn substitution U.S. cash basis vs CBOT corn, China import tariffs and Pacific export corridors, ethanol and livestock feed demand, red vs white food grades, drought-tolerant Plains supply, Harbor Ag grain monitor worked example, indicator decision table, pitfalls, and checklist.
• Lentil prices explained: red vs green grades, Canada exports and India demand Red masoor vs large green Laird grade spreads, Saskatchewan FOB and India CIF benchmarks, Canada and Australia export cycles, Indian MSP and stock limits, protein rotation with wheat and canola, Harbor Ag pulse monitor worked example, indicator decision table, pitfalls, and checklist.
• Canola and rapeseed prices explained: ICE futures, crush margins and biodiesel demand ICE Winnipeg and MATIF rapeseed benchmarks, Canadian and EU supply, crush margin economics, renewable diesel and biodiesel policy, China seed imports, Harbor Ag oilseed monitor worked example, indicator decision table, pitfalls, and checklist.
• Lithium prices explained: carbonate, hydroxide, EV batteries and supply cycles Battery-grade carbonate vs hydroxide benchmarks, Australia spodumene and Chile brine supply, China refining, EV cathode chemistry shifts, CME futures and LIT ETF, Harbor Industrial battery metals monitor worked example, indicator decision table, pitfalls, and checklist.
• Cobalt prices explained: battery metals, DRC supply and cathode chemistry shifts LME and Fastmarkets benchmarks, DRC copper-cobalt mines and artisanal risk, cobalt sulfate for NMC cathodes, LFP substitution, China refining and Indonesia HPAL, Harbor Industrial battery metals monitor worked example, indicator decision table, pitfalls, and checklist.
• Graphite prices explained: battery anodes, EAF electrodes and flake vs synthetic supply Natural flake and spheronized battery-grade benchmarks, EV anode and steel electrode demand, China processing and export licensing, spheronization bottlenecks, Harbor Industrial battery materials monitor worked example, indicator decision table, pitfalls, and checklist.
• Copper prices explained: LME, COMEX, China demand and electrification LME and COMEX benchmarks, mine supply and scrap recycling, construction and EV wiring demand, China PMI and inventory signals, Dr Copper growth correlation, Harbor Industrial monthly read worked example, indicator decision table, pitfalls, and checklist.
• Aluminum prices explained: LME, COMEX, energy costs and the green-metal trade LME and COMEX ALI benchmarks, bauxite-to-smelter supply chain, electricity-intensive production and regional power costs, China capacity and export policy, transport and packaging demand, copper substitution, Harbor Industrial monthly read worked example, indicator decision table, pitfalls, and checklist.
• Zinc prices explained: LME, galvanizing demand, smelter supply and the steel link LME SHG zinc benchmarks, mine concentrate and smelter refining, hot-dip galvanizing and die-casting demand, China steel and property cycles, treatment charges and energy-driven curtailments, Harbor Industrial monthly read worked example, indicator decision table, pitfalls, and checklist.
• Tin prices explained: LME, electronics solder, Indonesia supply and tinplate demand LME Grade A tin benchmarks, cassiterite mining and smelting, lead-free solder and tinplate can demand, Indonesia export rules and Myanmar supply risk, ITSCI traceability, Harbor Industrial monthly read worked example, indicator decision table, pitfalls, and checklist.
• Iron ore prices explained: Platts IODEX, China steel demand and seaborne supply Platts IODEX 62% Fe CFR China benchmarks, Pilbara and Vale seaborne supply, blast-furnace steel demand, China port inventories and property cycles, grade spreads and freight, Harbor Industrial monthly read worked example, indicator decision table, pitfalls, and checklist.
• Steel prices explained: HRC, rebar, China output and mill margins Hot-rolled coil and rebar benchmarks, SHFE and CME HRC futures, blast-furnace vs EAF routes, China crude steel output and export policy, scrap and iron ore margin spreads, Harbor Industrial steel monitor worked example, indicator decision table, pitfalls, and checklist.
• Lumber prices explained: CME futures, housing demand and North American supply CME Random Length LBS benchmarks, dollars per thousand board feet quoting, framing lumber vs OSB panels, Canada–U.S. softwood tariffs, single-family housing and remodel demand, sawmill capacity cycles, Harbor Construction materials monitor worked example, indicator decision table, pitfalls, and checklist.
• 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.
• ETF premium and discount to NAV explained: arbitrage, iNAV and execution Why ETF market prices diverge from net asset value — premium/discount math, authorized participant creation-redemption arbitrage, iNAV monitoring, illiquid and stressed-market cases, Harbor Capital sleeve refactor, technique decision table vs mutual funds and CEFs, pitfalls, and checklist.
• Master limited partnerships (MLPs) explained: midstream income, K-1 taxes and pipeline economics Publicly traded energy infrastructure partnerships — pipeline and storage assets, GP/LP structure, distributable cash flow coverage, K-1 and UBTI tax rules, incentive distribution rights, Harbor Capital energy income sleeve refactor, technique decision table vs REITs and BDCs, pitfalls, and checklist.
• Business development companies (BDCs) explained: private credit, high yields and middle-market lending Publicly traded private lenders — middle-market loan portfolios, 90% payout rules, leverage and fee structures, NAV discounts, non-accrual monitoring, Harbor Capital income sleeve refactor, technique decision table vs CEFs and bank-loan ETFs, pitfalls, and checklist.
• Closed-end funds explained: fixed share supply, premia, discounts and income strategies Exchange-traded pooled funds with no daily redemption — persistent NAV premia and discounts, structural leverage, option-income and muni CEF categories, distribution yield vs return of capital, Harbor Capital income sleeve refactor, technique decision table vs ETFs and mutual funds, pitfalls, and checklist.
• Leveraged and inverse ETFs explained: daily reset, volatility decay and risks 2x/3x daily targets vs long-horizon returns — volatility drag, inverse path dependency, swap costs, Harbor Capital tactical hedge worked example, vehicle decision table, pitfalls, and checklist.
• Efficient market hypothesis explained: weak, semi-strong and strong forms Do prices already reflect available information? — three forms of market efficiency, random walk theory, evidence for and against EMH, passive vs active investing implications, Harbor allocator worked example, decision table, pitfalls, and practitioner checklist.
• 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.
• Capital Asset Pricing Model (CAPM) explained: beta, expected return and the security market line Systematic vs diversifiable risk, CAPM formula and equity risk premium, security market line and Jensen’s alpha, beta estimation, Harbor Capital equity sleeve worked example, model decision table, pitfalls, and investor checklist.
• Equity risk premium explained: historical vs forward ERP, implied premiums and asset allocation Expected stock return over risk-free — historical arithmetic vs geometric spreads, building-block and implied ERP from market prices, international premia, DCF and glide-path use cases, Harbor Capital endowment worked example, method decision table, pitfalls, and investor checklist.
• Modern portfolio theory explained: efficient frontier, mean-variance optimization and CAPM Markowitz mean-variance optimization, efficient frontier and tangency portfolio, capital market line, CAPM beta connection, estimation-error limits, three-asset worked example, framework decision table, pitfalls, and investor checklist.
• Black-Litterman portfolio optimization explained: equilibrium returns, views and Bayesian blending Stable weights from market-implied returns — reverse optimization and tau, absolute and relative investor views, omega confidence matrices, posterior blending with mean-variance, Harbor Capital multi-asset sleeve worked example, approach decision table, pitfalls, and checklist.
• Risk parity investing explained: equal risk contribution, leverage and All Weather portfolios Allocate by volatility not dollars — risk contribution math, inverse-vol and ERC weighting, leveraged vs unlevered sleeves, All Weather construction, Harbor Capital multi-asset allocator worked example, approach decision table, pitfalls, and checklist.
• 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 capture strategy explained: ex-dividend timing, price drops and tax friction Short-term dividend harvesting — buy before ex-div, sell after payment, mandatory price adjustment, spread and ordinary-tax drag, special-dividend gap risk, Harbor Capital income sleeve refactor, technique decision table vs buy-and-hold and covered calls, pitfalls, and checklist.
• Dividend investing explained: yield, payout ratios and income strategies
• Dividend payout ratio explained: sustainability, FCF coverage and income analysis EPS and FCF payout formulas, retention ratio vs yield, sector benchmarks for REITs and utilities, Harbor Capital dividend sleeve worked example, metric decision table, pitfalls, and investor checklist.
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.
• Consumer Price Index (CPI) explained: inflation measurement, core CPI and portfolio impact How BLS builds the CPI basket — headline vs core, CPI vs PCE, shelter lag, real vs nominal returns, TIPS/I-bonds/COLA links, worked example, decision table, and an investor checklist.
• CPI shelter inflation explained: owners' equivalent rent, rent sampling and the lag Why shelter dominates CPI — BLS OER imputation, rent of primary residence six-panel rotation, CPI vs Zillow spot rents, headline and core weight, PCE shelter differences, Harbor Credit Union ALM refactor, technique decision table vs home-price proxies, pitfalls, and checklist.
• Personal income explained: BEA wages, transfers, disposable income and the savings rate BEA Personal Income and Outlays — wage and salary disbursements, proprietors and transfer payments, disposable income after taxes, real income vs inflation, personal saving rate, PCE and GDP link, Harbor Credit Union monthly macro read worked example, indicator decision table, pitfalls, and checklist.
• Real disposable personal income explained: BEA deflator, purchasing power and consumption signals After-tax purchasing power — nominal DPI vs PCE-deflated RDPI, per capita reads, real wage and transfer decomposition, savings identity with real PCE, Harbor Credit Union consumer lending desk refactor, technique decision table vs payroll-only reads, pitfalls, and checklist.
• Household debt service ratio explained: DSR, financial obligations and consumer stress Fed Z.1 payment burden — debt service ratio vs financial obligations ratio, mortgage and consumer decomposition, historical ranges and rate-cycle pass-through, Harbor Credit Union delinquency desk refactor, technique decision table vs credit balances-only, pitfalls, and checklist.
• Personal savings rate explained: BEA identity, excess savings and consumption sustainability Household saving flow — DPI minus outlays identity, cyclical and precautionary drivers, post-COVID excess savings stock vs flow, wealth effects, Fed Z.1 cross-check, Harbor Credit Union deposit sleeve refactor, technique decision table vs confidence-only reads, pitfalls, and checklist.
• Corporate profits explained: BEA NIPA, GDP income and earnings season Bureau of Economic Analysis profits from current production — pre-tax vs after-tax, IVA and capital consumption adjustments, NIPA vs S&P 500 GAAP earnings, profit share of GDP, financial vs nonfinancial split, Harbor Capital quarterly macro read worked example, indicator decision table, pitfalls, and checklist.
• Personal consumption expenditures (PCE) explained: Fed inflation target, core PCE and GDP consumption BEA monthly consumption and price indexes — nominal vs real PCE, goods vs services, core vs headline, PCE vs CPI methodology, personal income and savings rate, Harbor Credit Union macro read worked example, indicator decision table, pitfalls, and checklist.
• Trimmed mean PCE explained: Dallas Fed underlying inflation, core vs headline and Fed policy Dallas Fed symmetric trimming — monthly and 12-month trimmed mean PCE, sticky vs flexible price aggregates, comparison with core and headline PCE, Harbor Credit Union ALM refactor, technique decision table vs CPI-only inflation models, pitfalls, and checklist.
• Producer Price Index (PPI) explained: wholesale inflation, final demand and CPI lead time How BLS measures producer prices — final vs intermediate demand stages, headline vs core PPI, PPI vs CPI lead-lag, margin squeeze signals, Harbor Manufacturing input-cost read worked example, indicator decision table, pitfalls, and checklist.
• Import-export price index explained: BLS MXD, trade inflation and terms of trade BLS monthly import and export price indexes — locality of origin vs destination, petroleum vs core trade inflation, dollar pass-through, PPI and CPI pipeline links, terms of trade, Harbor Export monthly read worked example, indicator decision table, pitfalls, and checklist.
• Purchasing Managers Index (PMI) explained: ISM, services, the 50 line and recession signals Monthly diffusion index from purchasing manager surveys — ISM vs S&P Global, manufacturing vs services PMI, New Orders and Prices Paid components, PMI vs GDP lead time, Harbor Logistics demand read worked example, indicator decision table, pitfalls, and checklist.
• Factory orders explained: Census M3 total manufacturing, durables vs nondurables and the orders pipeline Full M3 manufacturers book — total new orders vs durable goods subset, nondurable petroleum and chemicals, shipments unfilled orders and inventories, GDP and IP bridge, Harbor Manufacturing total-book refactor, technique decision table vs durable-goods-only, pitfalls, and checklist.
• Durable goods orders explained: Census M3, core capital goods and business investment Census manufacturers orders for long-lived goods — new orders vs shipments vs unfilled backlog, core capital goods ex aircraft, GDP equipment bridge, PMI and IP leading properties, Harbor Manufacturing release-day read worked example, indicator decision table, pitfalls, and checklist.
• Industrial production explained: Fed G.17, capacity utilization and GDP output Federal Reserve hard-data index of factory, mine, and utility output — manufacturing vs mining vs utilities, capacity utilization and slack, PMI confirmation, GDP industrial link, Harbor Manufacturing monthly read worked example, indicator decision table, pitfalls, and checklist.
• ISM Services PMI explained: business activity, employment and GDP consumption signals Non-manufacturing ISM survey — diffusion index math, business activity vs new orders leads, employment and payrolls, prices and services inflation, S&P Global PMI comparison, Harbor Analytics release-day refactor, technique decision table vs retail-sales-only models, pitfalls, and checklist.
• Dallas Fed Texas Manufacturing Outlook Survey explained: diffusion indexes, energy bias and late-month signals Eleventh District regional manufacturing survey — zero-breakeven diffusion math, production and new orders subindexes, Texas energy and petrochemical sector bias, late-month calendar role, ISM PMI comparison, Harbor Manufacturing month-end refactor, technique decision table vs national surveys, pitfalls, and checklist.
• Kansas City Fed Manufacturing Index explained: Tenth District survey, diffusion indexes and Plains factory signals Tenth District regional manufacturing survey — zero-breakeven diffusion math, production and new orders subindexes, OK/KS/NE energy and aerospace sector mix, fourth-Tuesday calendar pairing with Richmond Fed, Harbor Manufacturing month-end refactor, technique decision table vs national surveys, pitfalls, and checklist.
• Richmond Fed Manufacturing Index explained: Fifth District survey, diffusion indexes and Mid-Atlantic signals Fifth District regional manufacturing survey — zero-breakeven diffusion math, shipments and new orders subindexes, VA/NC/SC sector mix, fourth-Tuesday calendar role, Philly and Empire State comparison, Harbor Manufacturing month-end refactor, technique decision table vs national surveys, pitfalls, and checklist.
• Philadelphia Fed Manufacturing Index explained: Business Outlook Survey, diffusion indexes and regional signals Third District regional manufacturing survey — diffusion index math and 50 breakeven, release-week pairing with Empire State, new orders vs shipments, PA/NJ/DE sector mix, ISM PMI comparison, Harbor Manufacturing release-week refactor, technique decision table vs national surveys, pitfalls, and checklist.
• Empire State Manufacturing Index explained: NY Fed survey, diffusion indexes and early cycle signals NY Fed regional manufacturing survey — diffusion index math and 50 breakeven, mid-month calendar role, new orders vs shipments, NY sector bias, ISM PMI comparison, Harbor Manufacturing release-day refactor, technique decision table vs national surveys, pitfalls, and checklist.
• Chicago PMI explained: MNI Business Barometer, Great Lakes manufacturing and month-end signals MNI private Great Lakes survey — diffusion index math and 50 breakeven, last-business-day calendar role, auto and steel sector bias, new orders vs backlogs, ISM PMI comparison, Harbor Manufacturing month-end refactor, technique decision table vs regional Fed surveys, pitfalls, and checklist.
• S&P Global Flash PMI explained: early manufacturing and services signals vs ISM S&P Global mid-month flash surveys — flash vs final methodology, diffusion index math and 50 breakeven, manufacturing and services release calendar, ISM PMI comparison, Harbor Manufacturing early-read refactor, technique decision table vs waiting for ISM only, pitfalls, and checklist.
• ISM Manufacturing PMI explained: diffusion indexes, new orders and cycle signals Institute for Supply Management survey — diffusion index math and 50 breakeven, new orders vs inventories leads, prices paid and supplier deliveries, S&P Global PMI comparison, Harbor Manufacturing release-day refactor, technique decision table vs IP-only models, pitfalls, and checklist.
• NFIB small business optimism explained: SBOI components, hiring plans and cycle signals National Federation of Independent Business monthly survey — ten-component optimism index (1986=100), employment and capital outlays plans, hard-to-fill jobs vs JOLTS, NFIB jobs report per-firm math, Harbor Staffing SMB desk refactor, technique decision table vs ISM-only models, pitfalls, and checklist.
• Capacity utilization explained: industrial slack, inflation pressure and the business cycle Fed G.17 utilization rates — manufacturing vs total industry, long-run averages and ~80% inflation threshold, slack vs supply constraints, output gap and PPI links, Harbor Manufacturing capex sleeve refactor, technique decision table vs IP-only models, pitfalls, and checklist.
• Retail sales explained: Census data, control group and GDP consumption Advance monthly retail trade — headline vs control group vs ex-auto/gas, category breakdown, seasonal adjustment and revisions, nominal vs real spending, Harbor Retail release-day read worked example, indicator decision table, pitfalls, and checklist.
• Quarterly services survey explained: Census revenue data, NAICS sectors and GDP services bridge Census QSS nominal revenue by service industry — covered NAICS sectors, seasonal adjustment and revisions, QSS vs retail sales and ISM Services PMI, BEA PCE bridge, Harbor Hospitality nowcast refactor, technique decision table vs diffusion-only models, pitfalls, and checklist.
• Motor vehicle sales explained: SAAR units, dealer revenue and rate sensitivity Census motor vehicle dealer dollars vs industry unit SAAR — new vs used, fleet vs retail, incentive and inventory cycles, auto loan affordability, Harbor Auto desk GDP bridge refactor, indicator decision table vs retail-sales-only, pitfalls, and checklist.
• Wholesale trade sales and inventories explained: Census data, stock-to-sales ratio and GDP Monthly Wholesale Trade Survey — wholesale sales vs merchant inventories, inventory-to-sales ratio, durable vs nondurable breakdown, restocking vs destocking cycles, GDP private inventories link, Harbor Wholesale monthly read worked example, indicator decision table, pitfalls, and checklist.
• Business inventories explained: Census MTIS, retail stock and GDP investment Manufacturing and Trade Inventories and Sales — manufacturer vs wholesale vs retail tiers, total business inventory-to-sales ratio, restocking vs destocking cycles, GDP private inventories link, Harbor Retail monthly read worked example, indicator decision table, pitfalls, and checklist.
• Leading economic indicators explained: Conference Board LEI, components and recession signals U.S. Leading Economic Index — ten LEI components, leading vs coincident vs lagging indexes, six-month growth rate recession heuristics, Harbor Logistics monthly macro read worked example, indicator decision table, pitfalls, and checklist.
• Chicago Fed National Activity Index explained: CFNAI, MA3 and recession signals Chicago Fed 85-indicator composite — standardized CFNAI and three-month MA3, four category groups, diffusion index, recession and inflation thresholds, Harbor Logistics monthly macro refactor, technique decision table vs LEI-only models, pitfalls, and checklist.
• Consumer confidence index explained: Conference Board, Michigan sentiment and spending signals Household confidence surveys — Conference Board vs Michigan, Present Situation vs Expectations, labor differential and buying intentions, confidence vs actual spending, Harbor Retail monthly read worked example, indicator decision table, pitfalls, and checklist.
• University of Michigan consumer sentiment explained: preliminary vs final, inflation expectations and spending signals Surveys of Consumers — 1966 Q1 index math, preliminary and final releases, Index of Consumer Expectations vs current conditions, median 1-year and 5-year inflation expectations, buying conditions for durables, Harbor Retail sentiment desk refactor, technique decision table vs Conference Board-only, pitfalls, and checklist.
• Consumer credit explained: G.19 data, revolving debt and spending signals Federal Reserve G.19 consumer credit — revolving vs nonrevolving debt, credit card and auto loan trends, delinquency context, household balance sheets, Harbor Credit Union monthly macro read worked example, indicator decision table, pitfalls, and checklist.
• Case-Shiller home price index explained: repeat sales, metro indexes and shelter inflation S&P CoreLogic repeat-sales methodology, national vs 20-city composite, seasonally adjusted indexes, comparison to NAR median and FHFA HPI, shelter CPI lag, Harbor Realty monthly read worked example, indicator decision table, pitfalls, and checklist.
• New home sales explained: Census contracts, median price and builder demand Census New Residential Sales — contracts signed on new construction at SAAR, median sales price, months' supply of new homes, starts-to-spending pipeline, mortgage incentives and cancellations, GDP residential investment link, Harbor Development release-day read worked example, indicator decision table, pitfalls, and checklist.
• Existing home sales explained: NAR closings, inventory, prices and housing demand NAR resale closings at SAAR — median sales price, months' supply, mortgage lock-in effect, pending home sales lead time, existing vs new home sales vs starts, Harbor Realty release-day read worked example, indicator decision table, pitfalls, and checklist.
• Pending home sales explained: PHSI index, contract signings and housing pipeline leads NAR Pending Home Sales Index — contract signings vs closings, 2001=100 index math, regional Northeast/Midwest/South/West splits, one-to-three-month lead over existing sales, MBA purchase apps cross-check, Harbor Realty pipeline refactor, technique decision table vs closings-only, pitfalls, and checklist.
• Construction spending explained: Census C30, residential vs nonresidential and GDP Census Value of Construction Put in Place — private vs public, residential vs nonresidential, starts-to-spending pipeline, GDP fixed investment link, Harbor Development quarterly read worked example, indicator decision table, pitfalls, and checklist.
• NAHB Housing Market Index explained: builder sentiment, HMI components and housing cycle leads NAHB/Wells Fargo builder survey — present sales, six-month expectations and buyer traffic diffusion indexes, regional HMI tables, lead-lag vs Census permits, mortgage-rate sensitivity, Harbor Development sentiment read worked example, indicator decision table vs permits-only, pitfalls, and checklist.
• Building permits explained: Census authorization data, lead times and housing cycle signals Census New Residential Construction permits — single-family vs multifamily authorization counts, permit valuation fields, permits-to-starts pipeline, regional division tables, NAHB cross-checks, Harbor Development entitlement read worked example, indicator decision table vs housing starts, pitfalls, and checklist.
• Housing starts explained: permits, single-family vs multifamily and recession signals Census New Residential Construction — building permits lead time, single-family vs multifamily starts, seasonal adjustment, residential investment in GDP, mortgage-rate sensitivity, Harbor Development land-bank read worked example, indicator decision table, pitfalls, and checklist.
• Mortgage rates explained: primary-secondary spread, MBS pass-through and affordability 30-year fixed benchmarks, 10-year Treasury and MBS OAS decomposition, primary-secondary spread, Fed QE/QT transmission, payment-to-income affordability, lock-in effects, Harbor Development affordability sleeve refactor, technique decision table vs fed-funds-only models, pitfalls, and 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.
• Federal funds rate explained: target range, EFFR, SOFR and FOMC implementation Overnight interbank lending mechanics, target range vs effective federal funds rate, IORB and ON RRP corridor, SOFR benchmarks, FOMC dot plots and fed funds futures, Harbor Credit Union FOMC-day worked example, rate indicator decision table, pitfalls, and checklist.
• Fed funds futures explained: implied rate paths, FOMC probabilities and market pricing 30-day CME contract mechanics, 100-minus-price implied rates, meeting-by-meeting probability math, futures vs dot plots, SOFR basis conversion, Harbor Capital ALM hedge refactor, technique decision table vs dot-plot-only models, pitfalls, and checklist.
• FOMC dot plot explained: SEP median path, dispersion, long-run rate and how to read it Summary of Economic Projections mechanics — anonymous participant dots, median vs dispersion, longer-run neutral rate, quarterly SEP calendar, Harbor Capital ALM hedge refactor, technique decision table vs fed funds futures, pitfalls, and checklist.
• Fed bank stress tests explained: CCAR, DFAST, scenarios, capital buffers and dividend gates Supervisory stress test mechanics — DFAST vs CCAR, severely adverse scenarios, CET1 and stress capital buffer, distribution objections, Harbor Credit Union counterparty refactor, technique decision table vs portfolio stress tests, pitfalls, and checklist.
• Tier 1 capital and CET1 ratio explained: Basel III, risk-weighted assets and bank solvency Regulatory capital adequacy — CET1 vs Tier 1 vs total capital, RWA denominator mechanics, conservation and SCB buffer stacks, Harbor Credit Union counterparty refactor, technique decision table vs LCR and leverage ratio, pitfalls, and checklist.
• Loan loss provisions and CECL explained: allowance for credit losses, lifetime ECL and bank earnings CECL expected-loss accounting — incurred-loss vs lifetime ECL, PD/LGD macro overlays, segment ACL and PCD loans, Harbor Credit Union CRE watchlist refactor, technique decision table vs stress tests and CDS, pitfalls, and checklist.
• Money supply M2 explained: M1 vs M2, velocity, QE/QT and inflation link Fed H.6 monetary aggregates, M0/M1/M2 components, velocity of money, quantitative easing and tightening transmission, M2 growth vs CPI debates, Harbor Credit Union liquidity read worked example, indicator decision table, pitfalls, and checklist.
• Money multiplier explained: reserve requirements, bank lending and M2 creation Fractional-reserve deposit expansion, 1/rr textbook formula vs observed M2/base ratio, post-2008 excess reserves and IOER, QE transmission channels, Harbor Credit Union ALM sleeve refactor, technique decision table vs M2-only models, pitfalls, and checklist.
• Velocity of money explained: MV=PY, circulation speed and inflation transmission Quantity equation mechanics, income velocity measurement, secular decline and pandemic collapse, M2 growth vs CPI timing debates, Harbor Credit Union dual-trigger sleeve refactor, technique decision table vs M2-only models, pitfalls, and checklist.
• Monetary policy explained: central banks, inflation targets and policy tools Fed mandates, policy rates, QE/QT, forward guidance, transmission lags, hawkish vs dovish signals, Harbor Credit Union rate-cycle worked example, tool decision table, pitfalls, and investor checklist.
• Fed balance sheet explained: H.4.1 assets, reserves, SOMA and liquidity plumbing Central bank ledger mechanics — SOMA Treasuries and MBS, bank reserves vs TGA and overnight reverse repo, abundant vs scarce reserve regimes, H.4.1 weekly reads, Harbor Credit Union ALM sleeve refactor, technique decision table vs rate-only models, pitfalls, and checklist.
• Treasury General Account explained: TGA balance, fiscal flows and money-market liquidity U.S. Treasury cash at the Fed — TGA inflows and outflows, reserves drain and refill mechanics, H.4.1 and Daily Treasury Statement reads, tax and refunding seasonality, debt-ceiling drawdowns, Harbor Credit Union ALM desk refactor, technique decision table vs fed funds only, pitfalls, and checklist.
• Bank reserves explained: required vs excess reserves, Fed plumbing and money-market spreads Depository institution balances at the Fed — required vs excess reserves, abundant vs scarce reserve regimes, IORB and SOFR spreads, H.4.1 reserve aggregates, QT and TGA interaction, Harbor Credit Union liquidity desk refactor, technique decision table vs fed funds only, pitfalls, and checklist.
• Bank deposit beta explained: rate pass-through, NIM cycles and monetary policy transmission Deposit funding elasticity — cumulative vs marginal beta, segmented liability buckets, sticky vs high-beta franchises, NIM expansion and compression phases, Harbor Credit Union ALM refactor, technique decision table vs mortgage pass-through, pitfalls, and checklist.
• Bank net interest margin (NIM) explained: asset yields, funding costs and rate cycles Spread economics for depository institutions — NII over earning assets, quarterly NIM bridge (rate, mix, volume), hiking-cycle expansion and compression, Harbor Credit Union forecast refactor, technique decision table vs ROA and efficiency ratio, pitfalls, and checklist.
• Liquidity coverage ratio (LCR) explained: HQLA tiers, 30-day stress outflows and Basel III bank liquidity Basel III survival liquidity — Level 1/2A/2B high-quality liquid assets, net cash outflow runoff rates, 100% minimum and buffers, Harbor Credit Union wholesale funding refactor, technique decision table vs NSFR and bank reserves, pitfalls, and checklist.
• Net stable funding ratio (NSFR) explained: ASF, RSF and Basel III structural bank funding One-year funding stability — available stable funding vs required stable funding factors, maturity mismatch penalties, 100% minimum, Harbor Credit Union wholesale rollover refactor, technique decision table vs LCR and bank reserves, pitfalls, and checklist.
• Fed Financial Accounts (Z.1) explained: flow of funds, household balance sheets and sectoral balances Quarterly national financial accounts — household net worth and debt ratios, B.101 balance sheet, F.8 credit flows, sectoral balances identity, GDP and personal income cross-walks, Harbor Credit Union household leverage desk refactor, technique decision table vs G.19-only, pitfalls, and checklist.
• Inflation expectations explained: anchoring, surveys, breakevens and policy credibility Household and professional survey measures, TIPS breakevens and inflation swaps, anchoring vs de-anchoring, wage and price transmission, Harbor Manufacturing wage sleeve refactor, technique decision table vs spot-CPI-only models, pitfalls, and checklist.
• Forward guidance explained: Delphic vs Odyssean signals, dot plots and policy credibility Central bank communication as a policy tool — calendar vs outcome-based pledges, SEP and dot plot reading, credibility and time consistency, Harbor Credit Union ALM sleeve refactor, technique decision table vs rate-hike-only models, pitfalls, and checklist.
• Taylor rule explained: policy reaction functions, r-star and rate path benchmarks Taylor 1993 formula and inertial variants, inflation and output gaps, r-star estimation, Fed deviations, Harbor Credit Union rate-path overlay refactor, technique decision table vs dot-plot-only models, pitfalls, and checklist.
• r-star neutral rate explained: estimation, secular decline and policy stance Unobservable neutral rate of interest — real vs nominal benchmarks, Holston-Laubach-Williams and market-implied methods, secular decline drivers, Harbor Credit Union ALM sleeve refactor, technique decision table vs fixed anchors, pitfalls, and checklist.
• Output gap explained: potential GDP, economic slack and inflation pressure Actual vs potential GDP — positive and negative slack, CBO and filter estimation, Taylor rule and Phillips links, Harbor Manufacturing capacity sleeve refactor, technique decision table vs growth-rate-only models, pitfalls, and checklist.
• Labor force participation rate explained: prime-age trends, slack and macro signals Headline vs prime-age LFPR, discouraged and marginally attached workers, secular aging vs cyclical re-entry, CBO potential GDP links, Harbor Manufacturing hiring sleeve refactor, technique decision table vs unemployment-only models, pitfalls, and checklist.
• Quantitative easing explained: balance sheet expansion, asset purchases and market transmission Large-scale asset purchases, SOMA mechanics, Treasury vs MBS programs, transmission channels, QE vs rate cuts, QT unwind, Harbor Credit Union ALM refactor, technique decision table, pitfalls, and checklist.
• Quantitative tightening explained: balance sheet runoff, reserve drain and market impact Passive runoff vs active sales, SOMA caps, reserve scarcity and money-market spreads, term-premium effects, Treasury supply interaction, Harbor Credit Union ALM sleeve refactor, technique decision table vs rate-hike-only models, pitfalls, and checklist.
• Liquidity trap explained: zero lower bound, policy impotence and escape routes Keynesian money-demand mechanics, ELB constraints, trap taxonomy, Japan and post-crisis case studies, fiscal and QE escape routes, Harbor Capital duration sleeve refactor, technique decision table vs rate-cut-only models, pitfalls, and checklist.
• Bank lending standards explained: Fed SLOOS, credit tightening and cycle signals Senior Loan Officer Opinion Survey — net tightening vs easing standards, loan demand questions, C&I and CRE splits, monetary policy transmission to credit growth, Harbor Credit Union quarterly credit read worked example, indicator decision table, pitfalls, and checklist.
• Financial conditions index explained: NFCI, credit spreads and macro transmission Chicago Fed NFCI and ANFCI, Goldman Sachs FCI, component weights and decomposition, policy transmission lags to GDP, Harbor Credit Union ALM sleeve refactor, technique decision table vs policy-rate-only models, pitfalls, and checklist.
• Shadow banking explained: NBFIs, repo funding and financial stability Nonbank credit intermediation — money market funds, repo and securitization chains, regulatory arbitrage, post-2008 reforms, Harbor Capital liquidity sleeve refactor, technique decision table vs bank-only credit models, pitfalls, and checklist.
• Federal Reserve Beige Book explained: district anecdotes, FOMC prep and rate signals Summary of Commentary on Current Economic Conditions — 12 Fed district qualitative reports, eight-times-yearly FOMC timing, calibrated growth and inflation language, labor and price themes, anecdotal vs hard data, Harbor Logistics district-scan worked example, indicator decision table, pitfalls, and checklist.
• Balance of payments explained: current account, trade deficits and capital flows BOP double-entry accounting, current account vs financial account, goods and services trade balance, primary and secondary income, official reserves, twin deficits, FX adjustment, Harbor Export quarterly read worked example, indicator decision table, pitfalls, and checklist.
• Twin deficits explained: fiscal and current account linkages, FX and sustainability Savings-investment identity mechanics, when fiscal and external deficits move together, dollar privilege vs EM vulnerability, Harbor Export quarterly sleeve refactor, technique decision table vs single-deficit models, pitfalls, and checklist.
• Current account explained: trade balance, primary income and external sustainability Goods and services balance, primary and secondary income, CA/GDP sustainability metrics, NIIP and savings-investment link, FX and reserve implications, Harbor Export quarterly sleeve refactor, technique decision table vs trade balance alone, pitfalls, and investor checklist.
• Capital and financial account explained: FDI, portfolio flows and reserve assets BPM6 capital vs financial account taxonomy, direct investment vs portfolio vs other investment, reserve asset mechanics, hot money and sudden-stop risk, Harbor Export capital-flow sleeve refactor, technique decision table vs current account alone, pitfalls, and investor checklist.
• Exchange rate regimes explained: fixed pegs, managed floats and the impossible trinity IMF regime taxonomy, currency boards and crawling pegs, impossible trinity tradeoffs, peg-break and sudden-stop risk, Harbor Export regime-overlay refactor, technique decision table vs spot FX alone, pitfalls, and investor checklist.
• Interest rate parity explained: covered vs uncovered parity, forward premiums and FX valuation CIP and UIP mechanics, forward premium puzzle, post-crisis cross-currency basis deviations, Harbor Export hedge refactor, technique decision table vs spot-only models, pitfalls, and investor checklist.
• Advance goods trade balance explained: Census early indicator, GDP nowcasts and import demand Census Advance Economic Indicators — preliminary goods exports and imports one week before full trade, goods deficit vs services gap, BEA advance GDP bridge, advance inventory cross-check, Harbor Export desk refactor, technique decision table vs full report only, pitfalls, and checklist.
• Trade balance explained: goods vs services, deficits, net exports and GDP Exports minus imports, goods deficit vs services surplus, nominal and real balances, bilateral trade and value chains, tariffs and exchange-rate adjustment, Census and BEA data, Harbor Export monthly read worked example, indicator decision table, pitfalls, and checklist.
• Fiscal policy explained: government spending, taxation and deficits Automatic stabilizers, discretionary stimulus vs austerity, deficit financing and crowding out, debt sustainability, fiscal-monetary interaction, Harbor Municipal budget-cycle worked example, policy decision table, pitfalls, and investor checklist.
• Automatic stabilizers explained: built-in fiscal cushions, progressive taxes and counter-cyclical transfers Revenue and expenditure stabilizers, UI and means-tested transfers, cyclical vs structural deficits, Harbor Municipal budget sleeve refactor, technique decision table vs discretionary-only models, pitfalls, and checklist.
• Fiscal multiplier explained: government spending, tax cuts and GDP impact MPC and leakage, Keynesian vs neoclassical multiplier ranges, spending vs tax multipliers, balanced-budget identity, state-dependent sizing, Harbor Municipal stimulus sleeve refactor, technique decision table vs flat GDP add-ons, pitfalls, and checklist.
• Crowding out effect explained: government borrowing, interest rates and private investment Financial vs resource crowding out, loanable-funds and IS-LM channels, monetary offset and liquidity-trap exceptions, open-economy leakage, Harbor Municipal bond sleeve refactor, technique decision table vs flat fiscal multipliers, pitfalls, and checklist.
• GDP explained: nominal vs real growth, components and investor signals Gross domestic product measurement — expenditure and income approaches, C+I+G+NX components, nominal vs real GDP, GDP deflator vs CPI, revisions and limitations, Harbor Logistics quarterly read worked example, indicator decision table, pitfalls, and checklist.
• Gross domestic income (GDI) explained: income approach, statistical discrepancy and GDP revisions Income-side GDP measurement — compensation, corporate profits, proprietors' and rental income, taxes minus subsidies, GDI vs GDP and the statistical discrepancy, BEA release calendar, Harbor Logistics dual-approach refactor, technique decision table vs expenditure-only models, pitfalls, and checklist.
• GDP nowcast explained: Atlanta Fed GDPNow, NY Fed models and pre-release growth estimates Running quarterly GDP tracking before BEA — bridge equations, GDPNow and NY Fed Staff Nowcast, release calendar, component contributions, tracking error, Harbor Logistics release-week refactor, technique decision table vs LEI-only models, pitfalls, and checklist.
• GDP deflator explained: implicit price index, real vs nominal GDP and inflation measurement BEA chain-weighted deflator — nominal/real GDP formula, component deflators for consumption/investment/government/trade, CPI and PCE divergences, Harbor Logistics segment deflation refactor, technique decision table vs CPI-only models, pitfalls, and checklist.
• Average hourly earnings explained: BLS wage growth, real pay and Fed signals BLS establishment survey wage series — production vs all-employee AHE, nominal and real wage growth, composition bias and sector dispersion, AHE vs ECI and unit labor costs, Harbor Staffing wage desk refactor, technique decision table vs payroll-headline-only, pitfalls, and checklist.
• Average weekly hours worked explained: BLS labor demand, overtime and recession signals BLS establishment survey hours series — production vs all-employee workweek, manufacturing overtime, aggregate hours index, labor hoarding and cyclical timing, Harbor Manufacturing hours desk refactor, technique decision table vs headline NFP-only, pitfalls, and checklist.
• ADP National Employment Report explained: private payrolls preview, methodology and NFP signals ADP paycheck microdata — National Employment Report vs BLS private payrolls, Stanford-era methodology, small vs large firm splits, sector detail, Jobs Wednesday calendar, Harbor Logistics preview read worked example, indicator decision table, pitfalls, and checklist.
• Nonfarm payrolls explained: NFP, revisions, wages and Fed signals BLS establishment survey — headline NFP vs private and government jobs, two-month revisions, average hourly earnings and weekly hours, birth-death adjustment, sector tables, ADP preview, Harbor Logistics release-day read worked example, indicator decision table, pitfalls, and checklist.
• Unemployment rate explained: U-3 vs U-6, payrolls and investor signals Labor force measurement — U-3 headline vs U-6 underemployment, participation rate, household vs establishment surveys, frictional vs cyclical unemployment, Sahm rule, JOLTS openings, Harbor Manufacturing monthly labor read worked example, indicator decision table, pitfalls, and checklist.
• Okun's law explained: GDP growth, unemployment gaps and output loss GDP-unemployment linkage — growth-rate and gap formulations, Okun coefficients, potential GDP and NAIRU, productivity and participation breaks, Harbor Manufacturing labor sleeve refactor, technique decision table vs payroll-only models, pitfalls, and checklist.
• Phillips curve explained: inflation, unemployment and labor market slack Original vs expectations-augmented Phillips curve, NAIRU and slack measures, wage vs price specifications, flat-curve episodes, Harbor Manufacturing wage sleeve refactor, technique decision table vs money-only models, pitfalls, and checklist.
• Wage-price spiral explained: feedback loops, unit labor costs and inflation persistence Nominal wage indexing and price pass-through, ULC momentum, expectations de-anchoring, breaking spirals with policy, Harbor Manufacturing wage sleeve refactor, technique decision table vs supply-shock-only models, pitfalls, and checklist.
• NAIRU explained: natural rate of unemployment, labor slack and inflation anchoring Non-accelerating inflation rate of unemployment — structural vs cyclical joblessness, Phillips and Beveridge estimation, secular u* drivers, Harbor Manufacturing wage sleeve refactor, technique decision table vs fixed unemployment anchors, pitfalls, and checklist.
• Initial jobless claims explained: weekly UI filings, seasonal adjustment and layoff signals DOL weekly unemployment insurance filings — initial vs continuing claims, four-week moving average, seasonal and holiday distortions, state-level concentration, Sahm rule lead time, Harbor Staffing layoff-alert refactor, technique decision table vs payroll-only models, pitfalls, and checklist.
• Challenger job cuts report explained: announced layoffs, industry breakdown and labor signals Challenger, Gray & Christmas monthly announcement tally — monthly vs YTD totals, industry and reason breakdowns, announced vs actual separations, lead time to claims and JOLTS, Harbor Staffing layoff-desk refactor, technique decision table vs UI filings-only, pitfalls, and checklist.
• JOLTS explained: job openings, quits rate, layoffs and the Beveridge curve BLS Job Openings and Labor Turnover Survey — openings vs hires, quits vs layoffs, Beveridge curve and openings-to-unemployed ratio, sector breakdown, JOLTS vs NFP calendar timing, Harbor Manufacturing monthly labor read worked example, indicator decision table, pitfalls, and checklist.
• Beveridge curve explained: vacancies, unemployment and labor market matching Vacancy-unemployment relationship — movement along vs outward/inward shifts, matching efficiency and V/U ratio, structural vs cyclical unemployment, Harbor Manufacturing hiring sleeve refactor, technique decision table vs unemployment-only models, pitfalls, and checklist.
• Multifactor productivity explained: TFP, capital services and BLS growth accounting BLS annual total factor productivity — KLEMS inputs, capital services vs capital stock, labor composition, MFP vs output per hour and ULC, Harbor Manufacturing capital-intensity desk refactor, indicator decision table vs labor-productivity-only, pitfalls, and checklist.
• Labor productivity explained: output per hour, unit labor costs and inflation BLS quarterly productivity and costs — nonfarm business output per hour, unit labor costs and hourly compensation, manufacturing vs aggregate sectors, multifactor productivity context, GDP and PPI links, Harbor Manufacturing quarterly read worked example, indicator decision table, pitfalls, and checklist.
• Unit labor costs explained: wage-productivity gap, BLS Productivity and Costs and Fed inflation signals BLS hourly compensation divided by output per hour — wage-minus-productivity identity, quarterly release anatomy and revisions, ULC vs ECI and average hourly earnings, PPI and CPI pass-through, Harbor Manufacturing margin desk refactor, indicator decision table, pitfalls, and checklist.
• Employment cost index explained: BLS wages, benefits and sticky inflation BLS quarterly ECI for total compensation — wages and salaries vs benefits, private vs government workers, industry and occupation detail, ECI vs payroll wages and unit labor costs, Fed sticky-services read, Harbor Logistics quarterly labor-cost worked example, indicator decision table, pitfalls, and checklist.
• Foreign exchange (forex) fundamentals explained: currency pairs, rates and risk Spot FX market structure, currency pair quoting, pips and spreads, interest-rate drivers, forwards vs options, carry trades, Harbor Exports EUR/USD hedging worked example, participant decision table, pitfalls, and checklist.
• DXY US Dollar Index explained: composition, drivers and how to read it ICE Dollar Index basket weights — euro-heavy G6 composition, Fed trade-weighted alternatives, rate differentials and risk sentiment, Harbor Exports hedge refactor, technique decision table vs bilateral pairs, pitfalls, and checklist.
• Purchasing power parity explained: absolute vs relative PPP, FX valuation and inflation Law of one price, absolute and relative PPP, Big Mac and OECD baskets, deviation drivers (Balassa-Samuelson, capital flows), Harbor Capital FX fair-value sleeve refactor, technique decision table vs carry and spot momentum, pitfalls, and checklist.
• FX forwards explained: outright contracts, forward points and currency hedging OTC currency forwards — outright forwards vs FX swaps, forward points and covered interest parity, mark-to-market hedging, NDFs for restricted currencies, Harbor Exports receivables refactor, technique decision table vs options and natural hedges, pitfalls, and checklist.
• Currency hedging and FX risk explained: transaction, translation and economic exposure Corporate FX risk taxonomy — transaction vs translation vs economic exposure, natural hedges and hedge ratios, cash-flow hedge accounting, Harbor Manufacturing treasury refactor, technique decision table vs unhedged FX, pitfalls, and checklist.
• Carry trade explained: FX funding, rate differentials and unwind risk Borrow low-yield funding currencies, invest in high-yield targets, swap points and rollover mechanics, uncovered interest parity, risk-off unwinds, Harbor Capital macro sleeve worked example, strategy decision table, pitfalls, and checklist.
• 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.
• Conference Board leading economic index explained: LEI components, diffusion and recession signals Monthly composite of ten forward-looking series — CEI and lagging index trio, six-month momentum and diffusion breadth, component contributions, Harbor Capital regime sleeve refactor, technique decision table vs yield-curve-only models, pitfalls, and checklist.
• Sahm rule explained: unemployment momentum, recession triggers and portfolio defenses Real-time recession signal from three-month unemployment averages — 0.5pp threshold, approach zones, false-clear traps, Harbor Credit Union ALM sleeve refactor, technique decision table vs yield-curve-only models, pitfalls, and checklist.
• Recession explained: NBER definition, causes, indicators and market impact How economic contractions are defined and dated — demand vs supply shocks, leading indicators (yield curve, Sahm rule, PMI, credit spreads), fiscal and monetary policy responses, Harbor Manufacturing worked example, signal decision table, pitfalls, and investor checklist.
• Terms of trade explained: export vs import prices, commodity windfalls and current account Net barter vs income terms of trade, commodity price cycles, exchange-rate pass-through, current account and GDP links, Harbor Export sleeve refactor, technique decision table vs trade balance alone, pitfalls, and investor checklist.
• Business cycle explained: expansion, peak, recession and recovery phases Four-phase taxonomy, output gap and potential GDP, nested inventory and credit cycles, sector rotation by phase, Harbor Capital regime sleeve refactor, technique decision table vs single-indicator models, pitfalls, and investor checklist.
• Stagflation explained: high inflation, slow growth and policy traps Supply vs demand drivers, Phillips curve breakdown, central bank dilemmas, asset-class behavior, Harbor Capital portfolio refactor, technique decision table vs recession-only models, pitfalls, and checklist.
• Disinflation explained: falling inflation rates, soft landings and portfolio positioning Disinflation vs deflation vs reflation, driver taxonomy, central bank pause dynamics, labor market signals, asset-class behavior, Harbor Capital duration sleeve refactor, technique decision table vs inflation-only models, pitfalls, and checklist.
• Real interest rates explained: nominal minus inflation, policy stance and portfolio impact Fisher equation, nominal vs real yields, real policy rate stance, TIPS and breakeven spreads, asset-class behavior across tightening cycles, Harbor Capital real-rate sleeve refactor, technique decision table vs nominal-only models, pitfalls, and checklist.
• Bear market investing explained: strategies, psychology and recovery Navigate 20%+ equity declines — drawdown phases, staying vs selling, dollar-cost averaging, rebalancing into fear, bond ballast, crypto winters, recovery math, decision table, and a retail checklist.
• 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.
• MOVE index explained: bond market volatility, Treasury options and rate risk ICE BofA MOVE construction from Treasury option implied vol, duration-weighted methodology, MOVE vs VIX divergence, Fed and yield-curve linkage, Harbor Capital ALM hedge refactor, technique decision table vs equity vol scaling, pitfalls, and checklist.
• GARCH volatility modeling explained: conditional variance, clustering and risk forecasts Time-varying volatility — ARCH and GARCH(1,1) parameters, persistence and mean reversion, EGARCH asymmetry, VaR and options applications, Harbor Capital risk desk worked example, model decision table, pitfalls, and checklist.
• 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.
• Futures contracts explained: margin, mark-to-market, contango and hedging Exchange-traded dated derivatives — contract specs, initial and maintenance margin, daily cash settlement, curve dynamics and roll yield, hedging vs speculation, Harbor Grain worked example, instrument decision table, pitfalls, and checklist.
• Treasury cash-futures basis trade explained: repo funding, CTD and leverage risk Long cash Treasuries short futures — gross and net basis, repo-funded leverage, cheapest-to-deliver and conversion factors, 2024–2025 deleveraging, Harbor Capital sleeve refactor, technique decision table vs outright duration, pitfalls, and checklist.
• Central counterparty clearing and variation margin explained: CCP waterfalls, IM and VM Novation and netting at CCPs — initial vs variation margin, SIMM and SPAN models, default waterfalls and mutualized funds, Harbor Capital cleared IRS refactor, technique decision table vs bilateral CSA, pitfalls, and checklist.
• Perpetual futures explained: funding rates, mark price and liquidation No-expiry crypto and synthetic perps — funding rate mechanics, mark vs index price, cross and isolated margin, liquidation engines, CEX vs on-chain perp DEXs, Harbor Exchange BTC perp worked example, instrument decision table, pitfalls, and checklist.
• 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.
• Put-call parity explained: synthetic positions, arbitrage and option pricing The no-arbitrage link between call and put prices — parity formula, conversion and reversal trades, synthetic long and short stock, dividend adjustments, Harbor Capital SPY desk worked example, strategy decision table, pitfalls, and checklist.
• Black-Scholes model explained: European option pricing, implied vol and Greeks The closed-form engine behind listed option quotes — lognormal assumptions, five inputs, call and put formulas, risk-neutral pricing, implied volatility and smiles, model limitations, Harbor Capital SPY desk worked example, pricing-model decision table, pitfalls, and 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.
• Options spreads explained: verticals, iron condors, straddles and multi-leg strategies Combine call and put legs for defined risk — bull and bear vertical spreads, straddles and strangles, iron condors and butterflies, calendar spreads, Harbor Capital SPY earnings iron condor worked example, strategy decision table, pitfalls, and checklist.
• Portfolio correlation matrix explained: covariance, diversification and risk concentration Build and read pairwise return correlations — Pearson vs Spearman, covariance to portfolio variance, rolling heatmaps, shrinkage estimators, eigenvalue concentration, Harbor Capital multi-asset sleeve refactor, technique decision table, pitfalls, and checklist.
• Hierarchical risk parity (HRP) explained: dendrogram clustering, quasi-diagonalization and robust weights Build portfolio weights without matrix inversion — correlation distance, tree clustering, recursive bisection, comparison with Markowitz and risk parity, Harbor Capital ETF sleeve refactor, allocator decision table, pitfalls, and checklist.
• Volatility targeting explained: risk scaling, leverage caps and portfolio vol control Keep portfolio risk near a policy band — scaling factor math, realized vs EWMA vs GARCH estimators, per-asset and portfolio-level targeting, CTA and risk-parity applications, Harbor Capital 60/40 sleeve refactor, allocator decision table, pitfalls, and checklist.
• Tactical asset allocation explained: dynamic overlays, signals and risk budgets Tilt around a strategic policy anchor — momentum and valuation signals, macro regime templates, overlay bounds and hysteresis, pairing with vol targeting and rebalancing, Harbor Capital multi-asset sleeve refactor, allocator decision table, pitfalls, and checklist.
• Regime switching models in finance explained: Markov states, volatility and allocation Hamilton Markov switching for bull, bear and crisis detection — state-dependent means and variances, filtered vs predicted probabilities, Harbor Capital 60/40 crisis overlay refactor, technique decision table vs GARCH and vol targeting, pitfalls, and allocator checklist.
• Conditional Drawdown at Risk (CDaR) explained: tail drawdowns, optimization and portfolio limits Average underwater pain beyond a drawdown threshold — path-dependent tail risk, DaR and CDaR definitions, Chekhlov-Uryasev LP optimization, Harbor Capital defensive sleeve refactor, technique decision table vs CVaR and vol targeting, pitfalls, and checklist.
• Variance risk premium explained: implied vs realized vol, VIX and harvest strategies Why options usually price more volatility than equities deliver — VRP math in vol and variance units, VIX measurement, delta-hedged short-vol overlays, Harbor Capital crisis kill-switch refactor, technique decision table vs covered calls and vol targeting, pitfalls, and checklist.
• Volatility skew explained: smile, risk reversals and tail-hedge sizing Why OTM puts trade rich on equity indices — vol smile vs skew, 25-delta risk reversal measurement, leverage effect and crash demand, Harbor Capital skew-aware tail-hedge refactor, technique decision table vs VRP and VIX level, pitfalls, and checklist.
• Quality factor investing explained: profitability, balance-sheet strength and defensive tilts Rank durable earners by gross profitability, ROE, leverage and earnings stability — Novy-Marx, Piotroski F-Score, quality minus junk, multi-factor blending with value and momentum, Harbor Capital equity sleeve refactor, implementation decision table, pitfalls, and checklist.
• Low volatility factor investing explained: the low-vol anomaly, beta and defensive tilts Overweight low-beta and low idiosyncratic-vol stocks — betting against beta, min-variance portfolios, sector biases and rate sensitivity, overlap with quality, Harbor Capital defensive sleeve refactor, implementation decision table, pitfalls, and checklist.
• Survivorship bias in investing and backtesting explained: delisted stocks, point-in-time data and realistic history Why backtests and fund databases overstate returns — delisting returns, index reconstitution, point-in-time universes vs today's constituents, Harbor Capital momentum sleeve refactor, bias detection decision table, pitfalls, and checklist.
• Backtesting trading strategies explained: walk-forward, costs, overfitting and realistic simulation Validate systematic rules before risking capital — in-sample vs out-of-sample splits, walk-forward rolls, survivorship and look-ahead bias, transaction costs and slippage, Harbor Capital momentum sleeve worked example, backtest method decision table, pitfalls, and checklist.
• Purged cross-validation for backtesting explained: embargo periods, label overlap and honest out-of-sample tests Stop label overlap from inflating ML strategy Sharpe — purged k-fold, embargo gaps, combinatorial purged CV and PBO, Harbor Capital momentum classifier refactor, validation method decision table, pitfalls, and checklist.
• Market microstructure explained: spreads, order books, liquidity and execution Where paper alpha meets real P&L — bid-ask spreads, limit order book depth, market makers, temporary vs permanent price impact, TWAP/VWAP and POV algos, Harbor Capital Russell rebalance worked example, execution method decision table, pitfalls, and checklist.
• Merger arbitrage explained: deal spreads, risk arb and event-driven returns Event-driven M&A trading — cash vs stock vs mixed consideration, spread annualization and implied probability, long-short hedging, antitrust and vote break risks, Harbor Capital healthcare acquisition worked example, strategy decision table, pitfalls, and 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.
• Behavioral finance explained: cognitive biases, loss aversion and smarter investing Why investors underperform their own funds — loss aversion, anchoring, recency bias, herd behavior, the disposition effect, prospect theory, the behavior gap, panic selling vs FOMO, and practical debiasing guardrails.
• Fama-French three-factor model explained: SMB, HML, factor loadings and alpha CAPM's equity extension — market plus size (SMB) and value (HML) factors, time-series regression interpretation, academic portfolio construction, Harbor Capital sleeve attribution refactor, model decision table vs CAPM and FF5, pitfalls, and allocator checklist.
• Fama-French five-factor model explained: RMW, CMA, profitability and investment factors FF3 extended with robust-minus-weak profitability and conservative-minus-aggressive investment — five-factor regression, factor portfolio sorts, Harbor Capital quality sleeve attribution refactor, model decision table vs FF3 and six-factor momentum, pitfalls, and allocator checklist.
• Carhart four-factor model explained: momentum, UMD and factor attribution Mark Carhart's FF3 plus momentum extension — UMD winner-minus-loser construction, four-factor regression interpretation, Harbor Capital tactical sleeve refactor, model decision table vs FF5 and six-factor, momentum crash risk, pitfalls, and allocator checklist.
• Grinold-Kahn fundamental law of active management explained: IC, breadth and information ratio The bridge from signal skill to fund outcomes — IR ≈ TC × IC × √BR, independent bets vs correlated positions, transfer coefficient and constraints, Harbor Capital systematic sleeve refactor, lever decision table, pitfalls, and allocator checklist.
• Information coefficient explained: IC, ICIR, factor signals and quant due diligence Cross-sectional ranking skill before portfolio construction — Spearman vs Pearson IC, mean IC and ICIR stability, IC decay and turnover, Grinold-Kahn breadth link, Harbor Capital factor sleeve worked example, metric decision table, pitfalls, and quant checklist.
• Information ratio explained: active return, tracking error and manager skill Risk-adjusted benchmark-relative performance — active return vs tracking error, IR formula and 0.5 hurdle, Grinold-Kahn breadth intuition, Harbor Capital active equity sleeve worked example, metric decision table, closet-indexer pitfalls, and checklist.
• Tracking error explained: index fund deviation, ETF replication and benchmark risk Excess return volatility vs benchmark — passive vs active interpretation, replication methods and sampling error, tracking difference vs TE, Harbor Capital ETF sleeve audit worked example, metric decision table, pitfalls, and investor checklist.
• Jensen's alpha explained: CAPM excess return, manager skill and performance attribution Risk-adjusted outperformance vs CAPM — alpha formula and regression intercept, beta and risk-free rate estimation, Jensen vs Treynor vs Sharpe vs information ratio, multi-factor extensions, Harbor Capital active equity sleeve worked example, metric decision table, pitfalls, and allocator checklist.
• Upside and downside capture ratio explained: fund performance in bull and bear markets Benchmark participation asymmetry — upside and downside capture formulas, capture ratio pairing and batting average, Harbor Capital manager review worked example, metric decision table vs Sharpe and alpha, pitfalls, and allocator checklist.
• Ulcer Index and Pain Index explained: drawdown depth, duration and investor comfort RMS underwater pain vs chronic grind — Ulcer Index and Pain Index formulas, Martin and Pain ratios, Harbor Capital global macro sleeve comparison, metric decision table vs Calmar and Sterling, pitfalls, and allocator checklist.
• Sterling ratio explained: return per average drawdown and CTA evaluation Chronic underwater pain vs tail risk — excess return divided by average drawdown, Sterling vs Calmar and Sharpe, Harbor Capital managed-futures sleeve worked example, metric decision table, methodology pitfalls, and allocator checklist.
• Omega ratio explained: probability-weighted gains, threshold returns and allocator due diligence Full distribution above vs below a hurdle — integral and discrete Omega, threshold L selection, Omega vs Sharpe and Sortino, Harbor Capital market-neutral sleeve worked example, metric decision table, pitfalls, and allocator checklist.
• Calmar ratio explained: return per maximum drawdown and crisis risk Drawdown-adjusted performance — annualized return divided by max drawdown, 36-month lookback, Calmar vs Sharpe and Sortino, Harbor Capital trend sleeve worked example, metric decision table, survivorship pitfalls, and allocator checklist.
• Treynor ratio explained: excess return per beta and systematic risk CAPM risk-adjusted performance — excess return divided by market beta, security market line intuition, Treynor vs Sharpe and information ratio, Harbor Capital active equity sleeve worked example, beta estimation pitfalls, and allocator checklist.
• Financial copulas explained: tail dependence, Sklar's theorem and portfolio risk Model joint asset behavior beyond linear correlation — Sklar's theorem, Gaussian vs t-copula vs Clayton/Gumbel, tail dependence coefficients, Monte Carlo VaR simulation, Harbor Capital multi-asset sleeve worked example, method decision table, pitfalls, and checklist.
• Expected Shortfall (CVaR) explained: tail risk, coherence and portfolio limits Average loss beyond VaR in the worst tail — coherence axioms vs VaR subadditivity, historical/parametric/Monte Carlo ES, FRTB regulatory context, backtesting and elicitability, Harbor Capital tail-risk sleeve worked example, method decision table, pitfalls, and checklist.
• Value at Risk (VaR) explained: portfolio loss limits, methods and CVaR Daily loss quantiles at 95% and 99% confidence — historical, parametric and Monte Carlo methods, expected shortfall (CVaR), Harbor Capital allocator worked example, method decision table, correlation and liquidity pitfalls, and checklist.
• Portfolio stress testing explained: historical scenarios, factor shocks and reverse stress tests Crisis replay and hypothetical shocks — 2008/COVID/rate scenarios, correlation breakdowns, liquidity and funding stress, reverse stress to find binding loss limits, Harbor Capital multi-asset sleeve worked example, approach decision table, pitfalls, and 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.
• Pairs trading explained: cointegration, spread signals and market-neutral strategies Relative-value long-short — correlation vs cointegration, hedge ratios and z-score entries, beta-neutral sizing, Harbor Capital energy pair worked example, strategy decision table, pitfalls, and checklist.
• Mean reversion trading explained: z-scores, regimes and when prices snap back Bet on prices and spreads returning to a baseline — stationarity and Hurst tests, z-score and Bollinger entries, OU half-life, momentum vs reversion regimes, Harbor Capital sector-ETF sleeve worked example, strategy decision table, pitfalls, and checklist.
• Trend following trading explained: time-series momentum, breakouts and CTA-style systems Ride sustained moves with systematic rules — time-series vs cross-sectional momentum, Donchian and MA crossovers, ATR position sizing, managed futures CTAs, Harbor Capital multi-asset futures sleeve worked example, strategy decision table, pitfalls, and checklist.
• Long-short equity investing explained: market neutrality, gross exposure and stock selection Own winners and short losers — net vs gross exposure, beta and sector neutrality, borrow costs and short squeezes, 130/30 funds, Harbor Capital sector-neutral sleeve worked example, approach decision table, pitfalls, and checklist.
• Kelly criterion explained: optimal bet sizing, fractional Kelly and drawdown control Geometric growth maximization — discrete and continuous Kelly formulas, full vs half-Kelly, edge and variance estimation, Harbor Capital allocator worked example, sizing method decision table, pitfalls, and checklist.
• Maximum drawdown explained: peak-to-trough loss, recovery time and Calmar ratio The worst hole in your equity curve — peak-to-trough formula, underwater curves, asymmetric recovery math, Calmar ratio, asset-class benchmarks, leverage traps, sequence risk, and an investor checklist.
• Maximum adverse excursion and MFE explained: stop placement, trade excursions and edge ratio Per-trade path diagnostics — MAE and MFE formulas, excursion scatter plots, edge ratio, stop and target optimization from winner distributions, Harbor Capital momentum sleeve refactor, method decision table vs portfolio drawdown metrics, pitfalls, and checklist.
• Trading expectancy and profit factor explained: win rate, payoff ratio and per-trade edge Per-trade edge metrics — expectancy and R-multiple formulas, profit factor bands, payoff ratio vs break-even win rate, Harbor Capital mean-reversion sleeve refactor, metric decision table vs Sharpe and MAE/MFE, pitfalls, and checklist.
• Risk of ruin explained: bankruptcy probability, bet sizing and survival math Account survival odds — classic ruin formulas, fixed-fractional sizing sensitivity, Monte Carlo bootstrap simulation, Harbor Capital momentum sleeve refactor, method decision table vs Kelly and max drawdown, pitfalls, and checklist.
• Portfolio turnover and transaction costs explained: net alpha, capacity and implementation shortfall Trading friction math — turnover formulas, commission-spread-impact cost stacks, implementation shortfall, breakeven turnover, Harbor Capital factor sleeve refactor, method decision table vs buy-and-hold and rebalance-only, pitfalls, and checklist.
• Active share explained: closet indexing, manager conviction and benchmark overlap How different a fund really is from its benchmark — Cremers-Petajisto weight divergence formula, closet indexer detection, pairing with tracking error and information ratio, Harbor Capital manager review worked example, metric decision table, pitfalls, and checklist.
• Portfolio performance attribution explained: Brinson-Fachler, active return decomposition and allocator accountability Where alpha really comes from — allocation, selection and interaction effects, security-level and factor extensions, multi-period Carino linking, Harbor Capital Q1 sleeve review, method decision table, pitfalls, and checklist.
• VWAP and TWAP execution algorithms explained: benchmarks, slicing and implementation shortfall Institutional order execution — volume-weighted and time-weighted benchmarks, intraday volume curves, participation rate caps, POV and IS hybrids, Harbor Capital equity desk refactor worked example, algorithm decision table, pitfalls, and checklist.
• Sortino ratio explained: downside risk, MAR and risk-adjusted returns Return per unit of harmful volatility — downside deviation below a target (MAR), formula intuition, annualization, Sortino vs Sharpe vs Calmar, asymmetric strategies, crypto caveats, and an allocator checklist.
• 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 beta coefficient explained: CAPM, systematic risk and portfolio hedging Market sensitivity per 1% benchmark move — covariance formula, CAPM expected return, beta vs correlation, portfolio beta and index hedging, Blume adjustment, sector benchmarks, crypto regime caveats, and an investor 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.
• Target-date funds explained: glide paths, 401(k) defaults and retirement allocation Lifecycle funds that auto-rebalance — vintage year selection, to vs through retirement glide paths, TDF vs DIY three-fund portfolios, fee traps in 401(k) menus, tax placement, and a retail investor checklist.
• Moving averages explained: SMA, EMA, golden cross and trend signals Simple vs exponential vs weighted MAs, 50/200-day golden and death crosses, lag and whipsaws, dynamic support and resistance, multi-timeframe stacking, volume confirmation, worked example, decision table, and trader checklist.
• 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

• Threat modeling explained: STRIDE, data flow diagrams and secure design Find design flaws before shipping — assets and trust boundaries, STRIDE and attack trees, 90-minute workshop process, Harbor Commerce checkout IDOR worked example, methodology decision table, pitfalls, and checklist.
• Zero trust architecture explained: never trust, always verify and modern security Replace castle-and-moat VPNs with continuous verification — identity-centric access, device posture, micro-segmentation, mTLS, policy engines, ZTNA, phased rollout, decision table, pitfalls, and a production checklist.
• 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.
• NumPy fundamentals explained: ndarrays, broadcasting and vectorized computing Homogeneous ndarray shape and dtype, creation and indexing, views versus copies, broadcasting rules, ufuncs and linear algebra, memory layout, pandas and ML integration, Harbor Analytics rolling anomaly detector worked example, tooling decision table, pitfalls, and checklist.
• Polars fundamentals explained: lazy queries, expressions and fast DataFrames Rust-powered columnar analytics — eager vs lazy API, expression syntax, Parquet predicate pushdown, groupby and window functions, streaming collect, Harbor Analytics clickstream pipeline worked example, tooling decision table, pitfalls, and checklist.
• Pandas fundamentals explained: DataFrames, groupby and tabular data workflows Series and DataFrame objects, CSV and Parquet I/O, loc and iloc indexing, dtype hygiene and missing values, groupby aggregations, merges and joins, time-series resampling, Harbor Fleet trip analytics worked example, tooling decision table, pitfalls, and checklist.
• Jupyter fundamentals explained: notebooks, kernels and reproducible analysis Interactive computational notebooks — JupyterLab vs Notebook vs VS Code, cells and kernel lifecycle, IPython magic commands, widgets and rich outputs, nbconvert and Papermill, Harbor Analytics funnel dropout worked example, tooling decision table, pitfalls, and checklist.
• Plotly fundamentals explained: Express, Graph Objects and interactive charts Python interactive visualization — Plotly Express vs Graph Objects, figure/trace/layout model, hover and zoom, themes and subplots, Jupyter and Streamlit embedding, static HTML and Kaleido export, Harbor Analytics funnel dashboard worked example, tooling decision table, pitfalls, and checklist.
• Matplotlib fundamentals explained: figures, axes and publication-quality plots Python static visualization foundation — pyplot vs object-oriented API, Figure and Axes hierarchy, line scatter bar and histogram plots, rcParams styling, subplots and GridSpec, Seaborn integration, Harbor Analytics weekly KPI report worked example, tooling decision table, pitfalls, and checklist.
• Seaborn fundamentals explained: statistical plots, themes and faceting Python statistical visualization on Matplotlib — relational distribution and categorical plot families, themes and palettes, FacetGrid faceting, regression and heatmaps, Harbor Analytics cohort retention worked example, tooling decision table, pitfalls, and checklist.
• scikit-learn fundamentals explained: pipelines, estimators and tabular ML The Estimator API, preprocessing pipelines, ColumnTransformer, cross-validation, GridSearchCV, classifiers and regressors, model persistence, Harbor Payments fraud-scorer worked example, framework decision table, pitfalls, and checklist.
• Gradient descent explained: learning rate, batches and convergence Loss landscapes, learning rate tuning, batch vs stochastic vs mini-batch updates, momentum intuition, Harbor Payments fraud-scorer worked example, variant decision table, pitfalls, and training checklist.
• Linear algebra for machine learning explained: vectors, matrices and gradients Dot products and cosine similarity, matrix multiplication in neural layers, L1/L2 norms and regularization, covariance and PCA intuition, eigenvalues, gradients as vectors, Harbor embedding worked example, operation decision table, pitfalls, and checklist.
• Bias-variance tradeoff explained: underfitting, overfitting and model complexity Decompose generalization error into bias, variance, and noise — learning curves, the complexity U-curve, regularization levers, ensemble trade-offs, imbalanced classification pitfalls, and a practitioner checklist.
• Learning curves explained: diagnose underfitting, overfitting and data needs Training vs validation curves by epoch and data size — underfitting and overfitting patterns, labeling budget decisions, Harbor fraud-scorer worked example, curve-pattern decision table, pitfalls, and checklist.
• Curriculum learning explained: easy-to-hard training schedules and difficulty metrics Order training examples from simple to hard — fixed and model-based difficulty scores, pacing functions, self-paced and anti-curriculum variants, vision and NLP recipes, curriculum vs active learning, pitfalls, and a production checklist.
• Active learning explained: uncertainty sampling, human-in-the-loop and label-efficient ML Cut annotation cost with smart query strategies — pool-based and stream-based loops, margin and entropy sampling, diversity and core-set methods, cold-start bootstrapping, LLM fine-tuning curation, evaluation pitfalls, and a production checklist.
• Semi-supervised learning explained: pseudo-labels, consistency regularization and label-efficient training Train on a small labeled set plus abundant unlabeled data — smoothness and cluster assumptions, pseudo-labeling and self-training, FixMatch and Mean Teacher consistency, graph propagation, Harbor ticket-routing worked example, technique decision table, pitfalls, and checklist.
• Few-shot learning explained: N-way K-shot, prototypical networks and in-context LLMs Generalize from a handful of labels per class — metric and meta-learning methods, prototypical networks and MAML, LLM in-context prompting, Harbor support-ticket classifier worked example, technique decision table, pitfalls, and practitioner checklist.
• 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.
• Go (Golang) fundamentals explained: concurrency, simplicity and backend services Packages and go mod, structs and interfaces, goroutines and channels, explicit error handling, context cancellation, net/http services, testing with go test, static binaries for containers, and a production checklist.
• Rust fundamentals explained: ownership, memory safety and systems programming Ownership and borrowing, lifetimes, Result and Option error handling, Cargo and crates, traits and generics, async Tokio concurrency, Arc and Mutex patterns, Solana on-chain programs, WASM targets, Harbor Chain indexer worked example, language decision table, pitfalls, and 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.
• JAX fundamentals explained: grad, jit, vmap, pmap and Flax training NumPy-compatible arrays on accelerators, functional automatic differentiation, XLA jit compilation, vmap batching and pmap multi-device parallelism, Flax/Optax training stack, Harbor Fleet demand forecaster worked example, framework decision table, pitfalls, and checklist.
• PyTorch fundamentals explained: tensors, autograd, training loops and GPU Tensor operations and device placement, automatic differentiation, nn.Module layers, DataLoader pipelines, standard training loop, CUDA and mixed precision, torch.compile, Harbor Support classifier worked example, framework decision table, pitfalls, and checklist.
• Hugging Face Transformers explained: pipelines, tokenizers and the Model Hub Pipeline API, AutoTokenizer and AutoModel, Hub workflows, Trainer fine-tuning, inference optimization, Harbor Support ticket-router worked example, tooling decision table, pitfalls, and checklist.
• TensorFlow fundamentals explained: Keras, tf.data, training and TFLite Eager execution and Keras layers, tf.data pipelines with prefetch, compile/fit training loop and callbacks, GPU/TPU and mixed precision, SavedModel and TFLite export, Harbor Supply mobile classifier worked example, framework decision table, pitfalls, and checklist.
• Autoencoders and variational autoencoders (VAE) explained: latent space and generative models Encoder-decoder compression — reconstruction loss, undercomplete and denoising variants, sparse autoencoders, VAE ELBO and reparameterization trick, anomaly detection, VAE vs GAN vs diffusion table, and a practitioner checklist.
• Learning rate scheduling explained: warmup, cosine annealing and decay strategies Time-varying step sizes for neural network training — step and exponential decay, cosine annealing with restarts, warmup for transformers and large batches, ReduceLROnPlateau, one-cycle policy, schedule comparison table, and a practitioner checklist.
• Early stopping explained: validation monitoring, patience and overfitting control Halt training when validation metrics plateau — patience and min-delta tuning, restoring best weights, Keras PyTorch and XGBoost patterns, LR schedule coupling, LLM fine-tuning caveats, worked example, pitfalls, and a practitioner checklist.
• Dropout regularization explained: Bernoulli masking, rates and inference scaling Random neuron masking during training — inverted dropout math, placement in MLPs CNNs RNNs and transformers, rate selection by architecture, dropout vs L2 and batch norm, fine-tuning LLMs, and a practitioner checklist.
• Dimensionality reduction and PCA explained: variance, components and visualization Compress correlated features — PCA step-by-step, explained variance and scree plots, scaling pitfalls, t-SNE vs UMAP, autoencoder bottlenecks, curse of dimensionality, method comparison table, and a production checklist.
• UMAP and t-SNE explained: manifold learning, perplexity and embedding visualization Reveal structure in high-dimensional data — perplexity and KL divergence, n_neighbors and min_dist, PCA preprocessing, sklearn and umap-learn patterns, Harbor Analytics customer embedding visualization, method decision table, pitfalls, and checklist.
• Batch normalization explained: training stability, layer norm vs batch norm and inference mode How batch norm stabilizes deep training — internal covariate shift, gamma and beta parameters, training vs inference running statistics, batch norm vs layer norm and group norm, small-batch pitfalls, placement in CNN stacks, and a production checklist.
• Layer normalization explained: pre-norm transformers, RMSNorm and batch norm comparison Per-token mean and variance normalization — learnable scale and shift, pre-norm vs post-norm transformer blocks, RMSNorm in Llama-class LLMs, RNN stabilization, comparison with batch and group norm, decision table, and a practitioner checklist.
• Backpropagation explained: chain rule, computational graphs and gradient flow How neural networks learn — forward pass and loss, chain rule on computational graphs, gradients through linear/ReLU/softmax layers, vanishing and exploding gradients, autodiff frameworks, gradient checkpointing, debugging checklist, and paradigm comparison table.
• Activation functions explained: ReLU, sigmoid, softmax, GELU and nonlinearity Why stacked linear layers collapse without nonlinear gates — ReLU, Leaky ReLU, sigmoid, tanh, softmax, GELU and Swish, dead ReLU and vanishing gradients, hidden vs output layer rules, transformer defaults, decision table, and a practitioner checklist.
• Neural network optimizers explained: SGD, momentum, Adam, AdamW and learning rate schedules How optimizers turn gradients into weight updates — mini-batch SGD, momentum and Nesterov, AdaGrad and RMSprop, Adam vs AdamW weight decay, warmup and cosine schedules, gradient clipping, optimizer comparison table, and a production checklist.
• Linear regression explained: OLS, regularization and interpretable prediction The foundational regression model — least-squares objective, closed-form OLS and gradient descent, coefficient interpretation, R-squared and RMSE, Ridge and Lasso regularization, polynomial features, assumption checks, worked rent example, decision table, pitfalls, and checklist.
• Logistic regression explained: sigmoid, odds ratios and binary classification The interpretable classification baseline — sigmoid mapping, log-loss training, coefficient odds ratios, L1/L2 regularization, multiclass softmax, calibration, imbalance handling, model comparison table, and a production checklist.
• Bayesian inference explained: priors, posteriors, MCMC and credible intervals Update beliefs with data using Bayes theorem — prior and posterior distributions, conjugate Beta-Binomial updates, MCMC and variational inference, credible vs confidence intervals, Thompson sampling links, worked conversion example, pitfalls, and a practitioner checklist.
• Causal inference explained: DAGs, confounding, propensity scores and uplift Estimate cause-and-effect from data — correlation vs causation, directed acyclic graphs, confounders and colliders, ATE and CATE, randomized experiments, matching and propensity scores, diff-in-diff, RDD, instrumental variables, causal ML meta-learners, worked marketing example, decision table, pitfalls, and a practitioner checklist.
• Statistical significance and hypothesis testing explained: p-values, power and confidence intervals Frequentist decision framework — null and alternative hypotheses, p-values and alpha, Type I and Type II errors, statistical power, confidence intervals, t-tests and chi-square, multiple comparisons, frequentist vs Bayesian, worked conversion example, pitfalls, and a practitioner checklist.
• Bootstrap resampling explained: confidence intervals, BCa and ML evaluation Nonparametric uncertainty estimation — resampling with replacement, percentile and BCa intervals, paired vs independent vs cluster bootstrap, A/B lift and classifier metric CIs, Harbor Analytics checkout worked example, method decision table, pitfalls, and checklist.
• Bayesian optimization explained: Gaussian processes, acquisition functions and HPO Sequential black-box tuning — GP surrogates, expected improvement and UCB acquisition, TPE samplers, multi-fidelity BOHB scheduling, Harbor Analytics defect classifier worked example, method decision table, pitfalls, and checklist.
• Gaussian processes explained: kernels, uncertainty and Bayesian regression Distributions over functions with calibrated uncertainty — RBF and Matérn kernels, prior and posterior inference, hyperparameter optimization, sparse inducing-point approximations, Harbor Analytics demand forecasting worked example, method decision table, pitfalls, and checklist.
• Neural architecture search explained: AutoML, DARTS and efficient model design Automate CNN and model topology design — search spaces and strategies, evolutionary and RL NAS, one-shot supernets and DARTS, hardware-aware multi-objective constraints, Harbor Analytics factory defect classifier worked example, approach decision table, pitfalls, and checklist.
• Multi-task learning explained: shared representations, task heads and loss weighting Train one backbone on multiple objectives — hard vs soft parameter sharing, uncertainty and gradient loss weighting, negative transfer, Harbor Support ticket router worked example, approach decision table, pitfalls, and checklist.
• Naive Bayes explained: Bayes theorem, text classification and Laplace smoothing Probabilistic classification with the independence assumption — Gaussian vs Multinomial vs Bernoulli variants, spam-filter intuition, log-probability stability, smoothing, model comparison table, and a production checklist.
• K-nearest neighbors (KNN) explained: distance metrics, choosing K and lazy learning Instance-based classification without training — Euclidean, Manhattan and cosine distance, mandatory feature scaling, K selection and weighted voting, curse of dimensionality, ANN indexes for production, model comparison table, and a checklist.
• Support vector machines (SVM) explained: margins, kernels and classification Maximum-margin classifiers — linear and soft-margin geometry, hinge loss, support vectors, RBF and polynomial kernel trick, C and gamma tuning, multiclass extensions, model comparison table, and a production checklist.
• Loss functions explained: MSE, cross-entropy, focal loss and choosing the right objective What your model actually optimizes — regression vs classification losses, MSE and Huber, binary and categorical cross-entropy, focal loss and class weights, label smoothing, loss vs metrics, decision table, and a production checklist.
• Focal loss explained: hard example mining, class imbalance and RetinaNet training Down-weight easy negatives with the (1 − p_t)^γ modulating factor — γ focusing parameter and α class weights, PyTorch and detection patterns, fraud and vision use cases, Harbor Analytics chargeback model worked example, method decision table, pitfalls, and checklist.
• Label smoothing explained: soft targets, regularization and calibrated classifiers Replace hard one-hot labels with softened distributions — smoothing factor ε, overconfidence and calibration fixes, PyTorch and Keras patterns, mixup and distillation interactions, Harbor Analytics fraud model worked example, technique decision table, pitfalls, and checklist.
• 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.
• Knowledge distillation explained: teacher-student models, soft labels and LLM compression Compress large teachers into smaller students — temperature scaling, logit and feature distillation, LLM instruction distillation, capacity gap, loss functions, stacking with quantization, and a production checklist.
• Neural network pruning explained: magnitude, structured sparsity and model compression Remove redundant weights and neurons to shrink models — unstructured vs structured pruning, magnitude and movement criteria, iterative fine-tuning, lottery ticket hypothesis, Harbor Analytics edge classifier worked example, method decision table, pitfalls, and checklist.
• Mixed precision training explained: FP16, BF16, loss scaling and PyTorch AMP Train faster with less VRAM — FP32 vs FP16 vs BF16, Tensor Cores, dynamic loss scaling, autocast and GradScaler, gradient underflow, Harbor Analytics defect classifier worked example, format decision table, pitfalls, and checklist.
• Federated learning explained: FedAvg, on-device training and privacy-preserving ML Train models across phones and silos without centralizing raw data — cross-device vs cross-silo FL, FedAvg rounds, non-IID challenges, secure aggregation, differential privacy, and a production checklist.
• Feature scaling and normalization explained: standardization, min-max and when it matters Z-score, min-max, and robust scaling for ML — log transforms, train-only fitting, Harbor Payments fraud model worked example, scaler decision table, leakage pitfalls, and 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.
• Feature stores explained: online/offline features, point-in-time joins and train-serve parity Centralize ML feature definitions for batch training and low-latency inference — training-serving skew, PIT correct joins, batch vs streaming materialization, fraud-scoring worked example, decision table, pitfalls, and checklist.
• Feature selection explained: filter, wrapper and embedded methods Choose the lean feature subset that generalizes — variance and mutual-information filters, RFE and sequential search, Lasso and tree importance, multicollinearity, CV-safe pipelines, high-dimensional pitfalls, worked credit example, decision table, and a practitioner 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.
• Neural network weight initialization explained: Xavier, He and stable training Set starting weight scales so activations and gradients survive depth — fan-in and fan-out variance, Xavier/Glorot and He/Kaiming schemes, biases and embeddings, Harbor Analytics defect classifier worked example, init decision table, pitfalls, and checklist.
• Gradient clipping explained: global norm, value clipping and stable deep learning training Cap oversized update vectors before the optimizer step — global norm vs per-value clipping, threshold tuning, PyTorch clip_grad_norm_ and AMP placement, RNN/transformer/RL usage, Harbor Analytics LSTM churn worked example, method decision table, pitfalls, and checklist.
• Vanishing and exploding gradients explained: deep network training failures and fixes Why backprop signals die or blow up in deep stacks — chain-rule multiplication, ReLU vs sigmoid, normalization and residuals, gradient clipping, Harbor Payments fraud MLP worked example, fix decision table, pitfalls, and checklist.
• 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.
• Self-supervised learning explained: pretext tasks, contrastive learning and foundation models Train without manual labels — contrastive methods like SimCLR and CLIP, masked modeling in BERT and MAE, linear probes vs fine-tuning, embedding quality for retrieval, and when SSL beats annotation.
• Learning to rank explained: pointwise, pairwise, listwise and NDCG Optimize search and recommendation order — retrieval vs ranking stages, pointwise/pairwise/listwise paradigms, NDCG and MRR metrics, LambdaMART and neural rankers, Harbor catalog search worked example, approach decision table, pitfalls, and checklist.
• Semantic search explained: meaning-based retrieval, embeddings and vector ranking Find documents by meaning, not keywords — dense embeddings, ANN indexes, bi-encoder vs cross-encoder re-ranking, hybrid BM25 fusion, e-commerce worked example, NDCG evaluation, decision table, pitfalls, and checklist.
• Knowledge graphs explained: entities, relations, ontologies and GraphRAG Model facts as connected triples — RDF vs property graphs, ontology design, construction from databases and text, SPARQL and Cypher queries, entity resolution, LLM GraphRAG integration, e-commerce worked example, decision table, pitfalls, and checklist.
• TF-IDF explained: term frequency, inverse document frequency and sklearn Sparse text features that weight rare discriminative words — bag-of-words and n-grams, TF and IDF formulas, sublinear scaling and L2 norm, sklearn TfidfVectorizer options, Harbor Support ticket router worked example, representation decision table, pitfalls, and checklist.
• Topic modeling and LDA explained: latent Dirichlet allocation, inference and evaluation Unsupervised theme discovery in document collections — LDA generative process, Dirichlet priors, Gibbs and variational inference, sklearn LatentDirichletAllocation, choosing K and coherence metrics, Harbor Support KB discovery worked example, method decision table, pitfalls, and checklist.
• Word embeddings explained: Word2Vec, GloVe and dense vector representations Turn tokens into meaning-rich vectors — one-hot limits, Skip-gram and CBOW, GloVe co-occurrence factorization, FastText subwords, distributional semantics, polysemy, Harbor catalog search worked example, method decision table, pitfalls, and checklist.
• Cosine similarity explained: vector comparison for search, RAG and recommendations The default embedding comparison metric — geometric intuition, dot-product formula, L2 normalization, cosine vs Euclidean distance, top-k thresholds, hybrid search pairing, worked example, decision table, pitfalls, and checklist.
• Contrastive learning explained: InfoNCE, SimCLR, CLIP and embedding training Pull positives together and push negatives apart in embedding space — triplet and InfoNCE losses, SimCLR and MoCo, CLIP multimodal alignment, temperature scaling, hard negatives, retrieval evaluation, and a production checklist.
• CLIP explained: contrastive language-image pretraining, dual encoders and zero-shot vision Align images and text in a shared embedding space — dual ViT and text encoders, symmetric InfoNCE loss, zero-shot prompt templates, OpenCLIP and SigLIP variants, Harbor Commerce visual search refactor, technique decision table, pitfalls, and checklist.
• Information theory explained: entropy, KL divergence and mutual information Shannon entropy and surprise in bits, cross-entropy and KL divergence, mutual information for feature selection and tree splits, LLM perplexity, Harbor Payments fraud-scorer worked example, metric decision table, pitfalls, and checklist.
• Cross-entropy explained: binary, categorical loss and softmax Information-theory intuition, binary and categorical formulas, softmax pairing, maximum likelihood, label smoothing, Harbor fraud-scorer worked example, loss decision table, pitfalls, and checklist.
• Data augmentation explained: image, text and tabular techniques for better ML models Synthetic training diversity without new labels — geometric and photometric image transforms, MixUp and CutMix, NLP paraphrase and back-translation, SMOTE for imbalance, AutoAugment policies, TTA at inference, train-serve parity traps, and a production checklist.
• Data leakage in machine learning explained: target, temporal and pipeline leaks Why offline metrics lie — target and label leakage, temporal lookahead, group contamination, preprocessing on full data, Harbor churn model worked example, leak-type decision table, pitfalls, and checklist.
• Explainable AI explained: SHAP, LIME, feature importance and model interpretability Turn black-box predictions into auditable reasons — global vs local explanations, permutation and tree importance, SHAP Shapley values, LIME surrogates, Grad-CAM for vision, fairness pitfalls, inference pipeline artifacts, and a production checklist.
• Isolation forest explained: anomaly scoring, path length and sklearn Unsupervised outlier detection via random partitions — isolation intuition, path-length scores, contamination and hyperparameters, sklearn IsolationForest patterns, Harbor Payments fraud scorer worked example, method decision table, pitfalls, and checklist.
• Anomaly detection explained: statistical methods, isolation forest, autoencoders and production alerting Finding outliers in data and live systems — point, contextual and collective anomalies, z-score and IQR baselines, isolation forest and autoencoders, time-series residuals, precision-recall on rare events, and alert fatigue prevention.
• Time series forecasting explained: ARIMA, seasonality, walk-forward validation and production ML Forecasting ordered data — trend and seasonality decomposition, ARIMA and Prophet, lag features and gradient boosting, walk-forward validation, MAPE vs RMSE, prediction intervals, cold start, and a production checklist.
• Conformal prediction explained: coverage guarantees, prediction sets and uncertainty Distribution-free prediction sets and intervals for any ML model — exchangeability, split conformal, nonconformity scores, APS and CQR, marginal vs conditional coverage, Harbor Payments fraud triage worked example, method decision table, pitfalls, and checklist.
• Out-of-distribution detection explained: MSP, energy scores, Mahalanobis and production guardrails Detecting when inputs leave the training distribution — covariate vs semantic shift, MSP and energy scores, ODIN, Mahalanobis distance in embedding space, deep ensembles and k-NN, Harbor Analytics document classifier worked example, method decision table, pitfalls, and checklist.
• Adversarial attacks in machine learning explained: FGSM, PGD, robustness and defenses Evasion attacks that fool models with tiny perturbations — threat models, FGSM and PGD, C&W optimization attacks, why neural nets are vulnerable, adversarial training and certified defenses, Harbor Analytics fraud classifier worked example, defense decision table, pitfalls, and checklist.
• Differential privacy explained: (ε, δ) guarantees, DP-SGD and privacy budget accounting Formal limits on what ML models leak about training data — epsilon-delta definition, Laplace and Gaussian mechanisms, DP-SGD and gradient clipping, privacy budget composition, local vs central DP, Harbor Analytics fraud model worked example, method decision table, pitfalls, and checklist.
• Model calibration explained: reliability diagrams, Platt scaling and trustworthy probabilities When predicted probabilities must match reality — reliability diagrams, Brier score and ECE, Platt scaling and isotonic regression, temperature scaling, discrimination vs calibration, fraud-model worked example, pitfalls, and a production checklist.
• Model ensembling explained: stacking, blending and combining diverse predictors Combine multiple ML models for better accuracy — voting and averaging, stacking with meta-learners, blending holdout weights, out-of-fold predictions, diversity vs correlation, Harbor Analytics fraud ensemble worked example, method decision table, pitfalls, and checklist.
• Model drift and concept drift explained: detection, PSI monitoring and retraining Why production models degrade — data drift vs concept drift vs label drift, covariate and prior shift, PSI and statistical tests, performance decay, shadow deployments, retraining triggers, and a production checklist.
• Multi-armed bandits explained: exploration, UCB, Thompson sampling and contextual bandits Learn while earning — regret and the exploration-exploitation tradeoff, epsilon-greedy, UCB confidence bounds, Bayesian Thompson sampling, LinUCB personalization, bandits vs A/B tests vs full RL, non-stationary arms, algorithm selection table, and a production checklist.
• Model serving explained: online inference, batching, GPU runtimes and production latency Turn trained models into reliable APIs — batch vs real-time vs streaming inference, ONNX and Triton runtimes, dynamic batching, autoscaling, canary rollouts, LLM KV-cache, fraud API worked example, decision table, and a production checklist.
• MLOps explained: ML pipelines, deployment, monitoring and governance Ship ML beyond the notebook — experiment tracking, feature stores, train-serve parity, batch and real-time serving, shadow and canary rollouts, CI/CD for data and models, drift monitoring, model registries, and a production checklist.
• MLflow fundamentals explained: experiment tracking, model registry and MLOps Open-source ML lifecycle platform — runs and parameters, metrics and artifacts, sklearn and PyTorch autologging, Projects packaging, Models flavors and signatures, registry stages and aliases, Harbor Analytics churn forecaster worked example, tooling decision table, pitfalls, and checklist.
• Weights & Biases (W&B) fundamentals explained: experiment tracking, Sweeps and Model Registry Cloud-first ML experiment platform — projects and runs, config and rich media logging, Artifacts and lineage, Sweeps hyperparameter search, Model Registry stages, PyTorch and Hugging Face integrations, Harbor Analytics defect classifier worked example, tooling decision table vs MLflow, pitfalls, and checklist.
• ML experiment tracking explained: runs, artifacts, reproducibility and model registry Log every training run with params, metrics, code and data versions — compare sweeps, reproduce results, promote models through registry stages, churn-classifier worked example, tool decision table, pitfalls, and checklist.
• Hyperparameter tuning explained: grid search, Bayesian optimization and best practices Hyperparameters vs model parameters, grid vs random vs Bayesian search, nested cross-validation, early stopping, Optuna and Hyperband, multi-objective tuning, leakage traps, and a production checklist.
• Optuna fundamentals explained: Bayesian hyperparameter search, pruning and distributed studies Open-source HPO framework — studies and trials, TPE and CMA-ES samplers, Median and Hyperband pruners, define-by-run search spaces, RDB storage and parallel workers, MLflow integration, Harbor Analytics defect classifier worked example, tooling decision table, pitfalls, and checklist.
• Decision trees and random forests explained: Gini splits, bagging and feature importance Tree-based tabular ML — Gini and entropy split criteria, pruning and stopping rules, bootstrap aggregating, out-of-bag error, hyperparameters, permutation importance, forest vs boosting comparison table, 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.
• Genetic algorithms explained: selection, crossover, mutation and fitness Evolution-inspired optimization for discrete and black-box problems — populations, fitness functions, tournament selection, crossover and mutation operators, elitism, Harbor Courier route-ordering worked example, method decision table, pitfalls, and checklist.
• Graph neural networks explained: message passing, GCN, GraphSAGE and node embeddings Learn on relational data — nodes, edges and adjacency, message-passing layers, GCN vs GraphSAGE vs GAT, node and graph classification, oversmoothing, inductive vs transductive training, fraud and molecule use cases, and a production checklist.
• ROC-AUC explained: ROC curves, TPR vs FPR and threshold-free classifier evaluation Ranking quality across every cutoff — true and false positive rates, AUC interpretation, when ROC misleads on imbalanced data, calibration vs ranking, PR-AUC comparison, and a production checklist.
• Class imbalance in machine learning explained: SMOTE, class weights and evaluation When positives are rare — why accuracy fails, oversampling vs undersampling, SMOTE and hybrid pipelines, class weights and focal loss, threshold tuning, PR-AUC vs ROC-AUC, fraud worked example, decision table, and a production checklist.
• 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.
• Optical character recognition (OCR) explained: document AI, CER and layout parsing Pixels to text — preprocessing, text detection vs recognition, CRNN and TrOCR, layout and table extraction, CER and field accuracy, Harbor Supply invoice digitization worked example, approach decision table, pitfalls, and checklist.
• Convolutional neural networks (CNN) explained: kernels, pooling, ResNet and vision models How CNNs learn spatial features — conv stride and padding, receptive fields, LeNet to ResNet architectures, transfer learning on small datasets, CNN vs ViT tradeoffs, Grad-CAM explainability, and a production checklist.
• Vision Transformers (ViT) explained: patch embeddings, pretraining and CNN trade-offs Images as patch token sequences — CLS classification, positional encoding, ImageNet-21k pretraining, fine-tuning with RandAugment and layer-wise LR decay, Swin and hybrid models, Harbor Supply defect detection worked example, architecture decision table, pitfalls, and checklist.
• Vision-language models explained: multimodal LLMs, image tokens and visual RAG CLIP dual encoders, LLaVA cross-attention fusion, unified multimodal transformers, instruction tuning, image token economics, multimodal RAG, Harbor Support screenshot triage worked example, architecture decision table, pitfalls, and checklist.
• Object detection explained: bounding boxes, YOLO, mAP and production Localize and classify every instance — IoU and NMS, two-stage R-CNN vs one-stage YOLO, focal loss, mAP@0.5:0.95 evaluation, anchor-free detectors, video tracking, quantization, domain shift, and a production checklist.
• Image segmentation explained: semantic, instance and panoptic masks Pixel-level vision — semantic vs instance vs panoptic tasks, U-Net and DeepLab encoders, Mask R-CNN and panoptic transformers, IoU and mIoU metrics, annotation workflows, Harbor defect-inspection worked example, method decision table, pitfalls, and checklist.
• Kalman filter explained: prediction, update and sensor fusion Track hidden states from noisy sensors — predict-update cycles, process and measurement noise, EKF and UKF variants, Harbor Courier GPS fusion worked example, filter decision table, pitfalls, and checklist.
• Particle filter explained: sequential Monte Carlo, resampling and multimodal state estimation Approximate Bayesian posteriors with weighted samples — SIR predict-weight-resample, importance proposals, degeneracy and resampling strategies, Harbor Logistics warehouse robot localization worked example, filter decision table, pitfalls, and checklist.
• Markov chain Monte Carlo (MCMC) explained: Metropolis-Hastings, Gibbs sampling and convergence Sample intractable Bayesian posteriors — Markov chains with the target as stationary distribution, Metropolis-Hastings and Gibbs updates, HMC/NUTS overview, burn-in and R-hat diagnostics, Harbor Analytics hierarchical A/B test worked example, method decision table, pitfalls, and checklist.
• Variational inference explained: ELBO, mean-field VI and fast approximate Bayes Turn Bayesian inference into optimization — ELBO derivation, mean-field and coordinate-ascent VI, reparameterization gradients and black-box ADVI, Harbor Analytics LDA topic-model refactor, method decision table vs MCMC and conjugate Bayes, pitfalls, and checklist.
• Gaussian mixture models and EM algorithm explained: soft clustering, density estimation and latent variables Fit multi-modal data with weighted Gaussians — E-step responsibilities, M-step parameter updates, covariance parameterizations and regularization, BIC model selection, Harbor Analytics merchant segmentation refactor, method decision table vs K-means and VI, pitfalls, and checklist.
• Markov chains explained: transition matrices, stationary distributions and HMMs Memoryless stochastic processes — transition matrices, ergodicity and stationary distributions, hidden Markov models, Harbor Courier delivery-state worked example, model decision table, pitfalls, and checklist.
• Hidden Markov models explained: latent states, Viterbi decoding and Baum-Welch EM Infer hidden state sequences from noisy observations — the HMM tuple, forward-backward likelihood, Viterbi decoding, Baum-Welch EM training, Gaussian and GMM emissions, Harbor Analytics pump health monitoring worked example, method decision table, pitfalls, and checklist.
• Markov decision processes explained: states, rewards, Bellman equations and optimal policies Sequential decision-making under uncertainty — the MDP tuple, policies, value and Q-functions, Bellman optimality, value and policy iteration, discount factors, Harbor Courier dynamic routing worked example, method decision table, pitfalls, and checklist.
• Policy gradient methods explained: REINFORCE, actor-critic, PPO and variance reduction Direct policy optimization — policy gradient theorem, REINFORCE, baselines and GAE, actor-critic architectures, PPO clipped objectives, continuous control, Harbor Logistics AMR pick-path refactor worked example, method decision table, pitfalls, and checklist.
• Monte Carlo Tree Search explained: UCB, rollouts, AlphaGo and game AI planning Selection, expansion, simulation and backpropagation — UCB1 exploration, neural policy and value networks, Harbor Chess midgame fork worked example, algorithm decision table, pitfalls, and checklist.
• 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.
• Instruction tuning and SFT explained: chat templates, datasets and LLM alignment Turn base models into instruction-following assistants — demonstration datasets, chat templates, label masking on assistant tokens, Harbor Support tone refactor, technique decision table vs prompting and DPO, pitfalls, and checklist.
• Outcome reward models explained: Bradley-Terry training, PPO and best-of-N reranking Scalar scorers for full LLM completions — Bradley-Terry pairwise loss, reward head architecture, preference curation, overoptimization and reward hacking, Harbor Support ranking refactor, technique decision table vs DPO and PRMs, pitfalls, and checklist.
• LLM reward hacking explained: specification gaming, proxy rewards and alignment failures When optimizers exploit imperfect signals — Goodhart's law, length and sycophancy hacks, ORM overoptimization, PRM step gaming, verifier loopholes, Harbor Support politely-wrong ranking refactor, technique decision table vs human oversight, pitfalls, and checklist.
• LLM best-of-N sampling and rejection sampling explained: verifiers, ORMs and test-time compute Parallel candidate generation and scorer-guided selection — deterministic verifiers vs ORM/PRM reranking, early-stop rejection, pass@k curves, Harbor Analytics Python tutor refactor 62→88%, technique decision table vs self-consistency and PPO, pitfalls, and checklist.
• LLM tree-of-thought reasoning explained: branching search, value functions and BFS/DFS Search over intermediate reasoning states — thought decomposition, proposal and evaluation prompts, value heuristics and pruning, Harbor Logistics route-planning refactor 54→87%, technique decision table vs CoT and self-consistency, pitfalls, and checklist.
• LLM MCTS reasoning explained: Monte Carlo tree search, rollouts and test-time planning Adaptive inference search — UCB and PUCT selection, LLM policy priors, rollout simulation and backpropagation, Harbor Analytics math refactor 61→84%, technique decision table vs tree-of-thought and beam search, pitfalls, and checklist.
• LLM least-to-most prompting explained: problem decomposition and sequential solving Two-phase decompose-then-solve prompting — ordered subproblems, few-shot exemplars, structured prior-answers, Harbor Logistics routing refactor 48→79%, technique decision table vs CoT and tree-of-thought, pitfalls, and checklist.
• Direct preference optimization (DPO) explained: align LLMs without RL Train from pairwise preferences with a single classification-style loss — Bradley-Terry implicit rewards, beta and reference models, ORPO and KTO variants, Harbor Support chatbot worked example, method decision table, pitfalls, and checklist.
• LLM SIMPO simple preference optimization explained: reference-free alignment and length-normalized rewards Align from pairwise preferences without a reference model — length-normalized log probabilities, target reward margin gamma, Harbor Support chatbot refactor 61→74% win rate, technique decision table vs DPO and RLHF, pitfalls, and checklist.
• LLM ORPO odds ratio preference optimization explained: joint SFT and alignment without a reference model Merge supervised NLL on chosen completions with odds-ratio preference loss in one stage — lambda SFT weighting, Harbor Legal clause-QA refactor 68→81% accuracy, technique decision table vs DPO and SIMPO, pitfalls, and checklist.
• LLM KTO Kahneman-Tversky optimization explained: binary feedback alignment from unpaired labels Align from desirable/undesirable labels without pairwise matching — prospect theory loss aversion, reference-model anchoring, production thumbs-up/down pipelines, Harbor Support resolution rate 67→83%, technique decision table vs DPO and ORPO, pitfalls, and checklist.
• LLM preference data curation and labeling explained: pairwise rubrics, quality control and alignment pipelines Build high-quality preference datasets for DPO and reward models — pairwise vs pointwise labels, stratified sampling, blind side-by-side UI, length and position debiasing, Harbor Support DPO refactor 58→79% win rate, technique decision table vs synthetic-only pipelines, pitfalls, and checklist.
• LLM RLAIF explained: reinforcement learning from AI feedback, judge pipelines and alignment at scale Scale preference labeling with AI judges — rubric and constitution-guided comparisons, verifier-grounded pairs, teacher-student calibration against human anchors, PPO and DPO integration, Harbor Analytics SQL tutor refactor, technique decision table vs RLHF, pitfalls, and checklist.
• LLM verifiable rewards explained: executable checks, outcome RL and reasoning model training Train with programmatic pass/fail signals — math checkers, unit tests, SQL sandbox execution, JSON schema validators, composite reward shaping, GRPO and PPO integration, Harbor Analytics ORM-to-verifier refactor, technique decision table vs learned ORMs, pitfalls, and checklist.
• GRPO explained: group relative policy optimization for LLM reasoning Train reasoning models without a critic network — sample G completions per prompt, score with verifiable math and code rewards, normalize advantages within each group, KL to SFT reference, Harbor Analytics tutor worked example, method decision table, pitfalls, and checklist.
• Process reward models explained: step-level scoring for LLM reasoning PRM vs outcome reward models, step-level training labels, best-of-N and tree search at inference, process supervision in RL, Harbor Analytics tutor worked example, method decision table, pitfalls, and checklist.
• Constitutional AI explained: principles, critique-revision and RLAIF alignment Align language models with written constitutions — critique-revision loops, chain-of-thought supervision, RLAIF vs RLHF, constitution design and layering, Harbor Support moderation worked example, alignment method decision table, pitfalls, and checklist.
• LLM bias and fairness explained: demographic parity, evaluation and production mitigation Training skew and representational harm, stereotype amplification and allocative unfairness, fairness metrics and counterfactual evals, debiasing across data alignment RAG and guardrails, Harbor Support routing fairness worked example, mitigation decision table, pitfalls, and checklist.
• LLM scaling laws explained: Kaplan, Chinchilla and compute-optimal training Power-law relationships between parameters, data and FLOPs — Kaplan model-size scaling, Chinchilla 20 tokens per parameter, post-Chinchilla over-training, inference vs training scale, emergent abilities debate, Harbor Analytics budget worked example, decision table, pitfalls, and checklist.
• LLM quantization explained: INT4, GPTQ, AWQ and production trade-offs FP16 to INT8 and INT4 weight compression — post-training vs QAT, GPTQ and AWQ, GGUF and bitsandbytes, weight-only vs activation quant, KV cache compression, Harbor Analytics edge deployment worked example, decision table, pitfalls, and checklist.
• LLM FP8 inference explained: E4M3, E5M2, tensor cores and production serving Hopper and Blackwell FP8 GEMMs — E4M3 vs E5M2 formats, per-tensor dynamic scaling, weight-only vs weight-and-activation FP8, KV cache precision policy, Harbor Analytics gateway refactor, technique decision table vs INT4 and BF16, pitfalls, and checklist.
• 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.
• LangChain fundamentals explained: LCEL, chains, agents and RAG pipelines Runnable LCEL composition, chat models and prompts, tools and ReAct agents, memory, document loaders and retrievers, LangSmith tracing, Harbor Support ticket router worked example, framework decision table, pitfalls, and checklist.
• LlamaIndex fundamentals explained: indexes, query engines and production RAG Documents and nodes, ingestion pipelines, VectorStoreIndex, query and chat engines, retrievers and postprocessors, agents and workflows, Harbor Analytics policy knowledge base worked example, framework decision table, pitfalls, and checklist.
• LangGraph fundamentals explained: stateful agent graphs, checkpoints and human-in-the-loop StateGraph nodes and edges, typed state with reducers, conditional routing, tool loops, Postgres checkpoint persistence, interrupts for operator approval, subgraph composition, Harbor Logistics shipment agent worked example, framework decision table, pitfalls, and checklist.
• CrewAI fundamentals explained: role-based agents, tasks and production crews Agents with roles and goals, task decomposition and context chains, sequential and hierarchical processes, tools and memory, YAML crew configuration, CrewAI Flow routing, Harbor Marketing content crew worked example, framework decision table, pitfalls, and checklist.
• Pydantic AI fundamentals explained: type-safe agents, tools and structured outputs Agent and RunContext, dependency injection, validated tools, Pydantic result types, model providers, streaming and retries, Harbor Support ticket classifier worked example, framework decision table, pitfalls, and checklist.
• DSPy fundamentals explained: signatures, modules and prompt optimization Signatures and Modules, Predict and ChainOfThought, teleprompters and BootstrapFewShot, metrics and assertions, RAG compile pipelines, Harbor Analytics policy Q&A optimizer worked example, framework decision table, pitfalls, and checklist.
• LLM GEPA prompt optimization explained: reflective evolution, Pareto search and DSPy compile GEPA teleprompter — reflective instruction mutation, Pareto-efficient multi-metric selection, Harbor Analytics policy Q&A refactor 71→89%, technique decision table vs BootstrapFewShot and manual tuning, pitfalls, and checklist.
• Multi-agent orchestration explained: coordinating specialist LLM agents at scale Orchestrator-worker and hierarchical topologies, task decomposition and routing, shared state and handoffs, debate and critique patterns, cost and safety controls, Harbor Support escalation worked example, topology decision table, pitfalls, and checklist.
• 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 agent context budget and token management explained: allocation, compression and production limits Per-turn token caps for production agents — fixed tier allocation, rolling summarization, tool-result excerpting, prefill vs decode economics, Harbor Support refactor, technique decision table, pitfalls, and checklist.
• LLM agent context overflow recovery mid-run systems explained: preemptive budgets, emergency compaction and safe truncation Recover when context limits hit mid-loop — tokenizer preflight, per-append guards, four-rung compaction ladder, observation spill to store, Harbor Research 52→3.1% abandoned-run refactor, decision table vs restart-from-scratch, pitfalls, and checklist.
• LLM agent conversation history compaction and summarization systems explained: anchor preservation, structured rollups and safe pruning Compress long chat threads without losing commitments — message classification, structured rollup schemas, anchor invariants, tool-result archival, Harbor Legal 31→4.8% context-loss refactor, decision table vs naive truncation, pitfalls, and checklist.
• LLM agent prompt caching systems explained: prefix reuse, cache keys and prefill cost control Reuse cached prompt prefixes across agent turns — static vs dynamic segmentation, provider cache breakpoints, TTL and invalidation, tenant isolation, Harbor Analytics 52% prefill savings refactor, decision table vs compression alone, pitfalls, and checklist.
• LLM agent cost attribution and token accounting explained: per-run budgets, tool metering and FinOps Attribute LLM spend to runs, tools, and tenants — run ledgers, span-level cost tags, subagent budget slices, tool surcharges, Harbor Support $12→$4.10/run refactor, decision table vs cloud invoices only, pitfalls, and 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 text decoding strategies explained: greedy, beam search, top-p and temperature How models pick the next token — autoregressive loops, greedy vs beam search, top-k and nucleus sampling, temperature scaling, repetition penalties, Harbor Support chatbot worked example, method decision table, pitfalls, and checklist.
• RAG explained: retrieval-augmented generation Embeddings, vector search, chunking strategies, hybrid retrieval, reranking, and evaluation for knowledge-grounded LLM apps.
• LLM contextual retrieval explained: contextual embeddings, BM25 hybrid and RAG recall Index-time chunk enrichment with situating LLM preambles, dual dense and BM25 indexes on enriched text, Harbor Support knowledge base refactor, technique decision table vs parent-child chunking, pitfalls, and checklist.
• LLM ColBERT and late interaction retrieval explained: MaxSim, token embeddings and RAG recall Token-level embeddings with MaxSim scoring between bi-encoders and cross-encoders, PLAID compression, hybrid gating, Harbor Legal contract search refactor, technique decision table vs two-stage reranking, pitfalls, and checklist.
• LLM SPLADE sparse retrieval explained: learned lexical expansion, inverted indexes and hybrid RAG Sparse neural retrieval with SPLADE v2 — learned term activation, inverted-index scoring vs BM25 and dense embeddings, RRF fusion with bi-encoders, Harbor Support KB refactor on acronym-heavy queries, technique decision table, pitfalls, and checklist.
• RAG chunking strategies explained: fixed, semantic and parent-child retrieval Split documents for vector search — fixed-size vs structure-aware vs semantic chunking, overlap and metadata, parent-child indexes, contextual retrieval enrichment, Harbor Support knowledge base worked example, strategy decision table, pitfalls, and checklist.
• LLM agentic chunking explained: proposition splits, boundary agents and RAG ingest LLM-proposed semantic chunk boundaries — proposition extraction, validator loops, overlap and parent-child pairing, Harbor Legal handbook refactor, technique decision table vs fixed-size and semantic clustering, pitfalls, and checklist.
• LLM parent-child chunking explained: small-to-big RAG retrieval and dual-index architecture Hierarchical RAG chunking — small child embeddings for precision, large parent passages for synthesis context, deduplication and ranking flow, Harbor Legal handbook refactor, technique decision table vs fixed-size and late chunking, pitfalls, and checklist.
• LLM sentence window retrieval explained: small-chunk search, context expansion and RAG precision Search single sentences, synthesize neighbor windows — window sizing, overlap deduplication, section-boundary clamping, Harbor Support billing FAQ refactor, technique decision table vs parent-child and fixed chunks, pitfalls, and checklist.
• RAG citation and source attribution explained: inline references, span grounding and verifiable answers Link RAG claims to retrieved evidence — inline [n] markers, footnotes and highlighted spans, prompt-native vs post-hoc aligners, chunk metadata for audit trails, Harbor Archive policy portal refactor, technique decision table vs faithfulness metrics, pitfalls, and checklist.
• RAG document ingestion explained: PDF parsing, OCR, layout extraction and index pipelines Turn raw files into clean structured text for RAG — format detection, layout-aware PDF extraction, OCR for scans, table serialization, metadata and provenance, Harbor Archive policy corpus refactor, pipeline decision table, pitfalls, and checklist.
• RAG incremental index updates explained: stale embeddings, change detection and production refresh Keep vector indexes fresh without nightly full rebuilds — content-hash gating, chunk-level diff, tombstones and CDC sync, dual-index model migrations, Harbor Support knowledge base refactor, technique decision table vs brute-force re-embed, pitfalls, and checklist.
• LLM RAG document freshness decay explained: recency boosting, version supersession and stale-answer prevention Rank authoritative editions over retired policy chunks — effective_date metadata, exponential and step decay, supersession graph overrides, query-time vs index-time boosting, historical-mode routing, Harbor HR policy refactor, technique decision table vs hard date filters, pitfalls, and checklist.
• LLM multimodal RAG explained: image retrieval, visual grounding and document QA Ground answers in charts, diagrams and scanned PDFs — page-image embeddings, CLIP and ColPali indexes, dual-index fusion, VLM synthesis, Harbor Insurance claims refactor, technique decision table vs text-only RAG, pitfalls, and checklist.
• Information retrieval explained: inverted indexes, BM25 and search ranking Classical search before RAG — inverted indexes, TF-IDF and BM25 scoring, query tokenization, precision vs recall, NDCG evaluation, lexical vs semantic trade-offs, chunking for retrieval, and a production checklist.
• Recommendation systems explained: collaborative filtering, matrix factorization and ranking How Netflix and Spotify-style engines work — user-item matrices, collaborative vs content-based filtering, ALS and two-tower models, cold-start tactics, precision@K and NDCG, explore/exploit trade-offs, feedback loops, and a production checklist.
• 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.
• Graph RAG explained: knowledge graphs, community summaries and hybrid retrieval Entity and relationship extraction, graph merge and community detection, local vs global query modes, Microsoft GraphRAG and LightRAG patterns, Harbor Archive compliance Q&A worked example, architecture decision table, pitfalls, and checklist.
• Agentic RAG explained: iterative retrieval, self-correction and multi-step search Self-RAG and Corrective RAG loops, query decomposition and step-back prompting, ReAct-style tool orchestration, retrieval grading and re-querying, Harbor Support escalation agent worked example, architecture decision table, pitfalls, and checklist.
• LLM RAG chunking strategies explained: fixed, semantic, parent-child and overlap tuning Document splitting for retrieval — fixed vs semantic chunks, token budgets and overlap, heading-aware parsers, parent-child indexes, context headers, Harbor Support 34→8% retrieval-miss refactor, decision table vs whole-document embed, pitfalls, and checklist.
• LLM RAG evaluation and retrieval metrics explained: Precision@k, nDCG, faithfulness and golden sets Production RAG measurement — Precision@k, Recall@k, MRR, nDCG, faithfulness and context precision, golden Q&A set design, LLM-as-judge calibration, Harbor Legal policy-bot 59→91% faithfulness refactor, decision table vs vibe checks, pitfalls, and checklist.
• LLM Corrective RAG (CRAG) explained: retrieval grading, knowledge refinement and fallback search Grade-then-branch retrieval — cross-encoder evaluator tiers, knowledge refinement strips, BM25 and web fallback routing, Harbor Analytics metric-bot refactor, technique decision table vs reranking-only and Self-RAG, pitfalls, and checklist.
• LLM Self-RAG explained: reflection tokens, retrieval critique and adaptive generation Retrieve-generate-critique loops — IsREL, IsSUP, and IsUSE reflection tokens, inference vs fine-tuned critics, Harbor Legal policy-bot refactor, technique decision table vs CRAG and plain RAG, pitfalls, and checklist.
• LLM RAFT explained: retrieval augmented fine-tuning, oracle documents and distractor training Train the generator on realistic retrieved bundles — oracle plus hard distractors, chain-of-thought citation supervision, Harbor Compliance policy-bot refactor, technique decision table vs plain RAG and embedding fine-tuning, pitfalls, and checklist.
• RAG evaluation explained: faithfulness, context recall and retrieval quality metrics Stage-level RAG metrics — context precision and recall, answer faithfulness and relevance, golden QA datasets, LLM-as-judge and RAGAS-style scoring, offline regression vs online monitoring, Harbor Archive docs portal worked example, metric decision table, pitfalls, and checklist.
• LLM embedding drift monitoring explained: vector space degradation, golden sets and RAG regression alerts Detect silent retrieval regressions — model vs query vs corpus drift, golden-set recall@k monitors, centroid and neighbor stability checks, shadow-index remediation, Harbor Support encoder regression refactor, technique decision table vs ingest-only freshness, pitfalls, and checklist.
• LLM multilingual RAG explained: cross-lingual retrieval, query translation and embedding alignment Global knowledge-base design — language detection and routing, cross-lingual embeddings vs translate-query retrieval, per-block language tags, CJK and RTL chunking, answer locale control, Harbor Support international docs refactor, technique decision table vs translate-then-RAG, pitfalls, and 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 test-time compute explained: scaling inference, verifiers and reasoning models Spending FLOPs at inference instead of training bigger models — best-of-N sampling, self-consistency, process and outcome reward models, tree search and MCTS, o1-style adaptive reasoning, latency and cost tradeoffs, Harbor Support escalation worked example, approach decision table, pitfalls, and checklist.
• LLM model collapse explained: recursive training, diversity loss and production defenses How training on AI-generated text erodes tails and style — recursive collapse taxonomy, detection metrics, provenance and anchor mixing, Harbor Publishing writer-assistant refactor, technique decision table vs scale-only fixes, pitfalls, and checklist.
• LLM synthetic data generation explained: self-instruct, quality filters and fine-tuning datasets Bootstrap SFT and preference datasets with teacher models — self-instruct and evol-instruct pipelines, distillation and rejection sampling, deduplication and LLM-as-judge filters, contamination and mode-collapse risks, Harbor Support classifier worked example, approach decision table, pitfalls, and checklist.
• LLM tokenizer explained: BPE, SentencePiece, vocabulary size and production token budgets Byte-level BPE, WordPiece, and SentencePiece — vocabulary tradeoffs, special tokens, multilingual fragmentation, billing surprises, Harbor Analytics cost-router refactor, technique decision table vs character counting, pitfalls, and 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 embedding model selection explained: MTEB, domain fit and production RAG Golden-set recall@k vs leaderboard rank, model families and dimensions, asymmetric prefixes, Matryoshka truncation, hybrid and reranker pairing, Harbor Support retrieval refactor, technique decision table vs fine-tuning, pitfalls, and checklist.
• LLM embedding batch inference explained: throughput, padding and RAG indexing Static vs dynamic batching, length bucketing, GPU memory limits, TEI and vLLM embedding servers, ingest vs query paths, Harbor Analytics reindex refactor, technique decision table vs serial API calls, pitfalls, and checklist.
• LLM late chunking explained: context-aware embeddings and RAG recall Early vs late embedding pipelines, long-context encoders, token pooling at chunk boundaries, Harbor Legal contract ingest refactor, technique decision table vs contextual retrieval and parent-child indexes, pitfalls, and checklist.
• LLM Matryoshka embedding explained: nested dimensions and adaptive RAG retrieval Matryoshka Representation Learning, prefix truncation at 64/256/768, tiered ANN indexes, Harbor Analytics tiered-index refactor, technique decision table vs quantization and smaller models, pitfalls, and checklist.
• LLM vector metadata filtering explained: pre-filter ANN, ACL scopes and RAG safety Pre-filter vs post-filter vector search, payload indexes, tenant ACL schema design, hybrid BM25+vector filter parity, Harbor Legal multi-client refactor, technique decision table vs separate indexes, pitfalls, and checklist.
• LLM NLI faithfulness for RAG explained: entailment grading, claim verification and hallucination guards Natural language inference for RAG — entailment vs contradiction vs neutral, retrieval grading, claim decomposition, Harbor Support answer-guard refactor, technique decision table vs LLM-as-judge and cross-encoders, pitfalls, and checklist.
• LLM response grounding and factuality verification explained: claim decomposition, entailment checks and production gates Post-generation answer guards — atomic claim extraction, NLI entailment grading, citation span overlap, numeric and date parsers, confidence gating and abstention, Harbor Legal policy Q&A refactor, technique decision table vs prompt-only and human review, pitfalls, and checklist.
• LLM RAG document deduplication explained: near-duplicate detection, index hygiene and retrieval quality Exact and near-duplicate detection for RAG corpora — MinHash, SimHash, embedding similarity thresholds, ingest vs query-time dedup, Harbor Legal corpus refactor, technique decision table vs reranking-only, pitfalls, and checklist.
• LLM codebase RAG explained: AST chunking, symbol graphs and repository search RAG over source repositories — tree-sitter function chunks, symbol metadata, BM25 plus dense fusion, caller/callee expansion, Harbor Engineering monorepo refactor, technique decision table vs document RAG, pitfalls, and checklist.
• LLM cost optimization explained: token budgets, model routing and production savings Where inference spend comes from — input vs output economics, model cascades, prompt and RAG trimming, caching layers, quantization, Harbor support bot worked example, decision table, pitfalls, and checklist.
• LLM data privacy explained: PII, RAG leakage, retention and compliance Training and inference PII surfaces, RAG cross-tenant leakage, prompt logging and retention, GDPR and CCPA hooks, redaction pipelines, vector DB access controls, Harbor Support privacy architecture worked example, deployment decision table, pitfalls, and checklist.
• LLM A/B testing and online experimentation explained: randomization, metrics and statistical guardrails Run trustworthy production experiments on prompts, models and RAG stacks — sticky bucketing, primary metrics and guardrails, CUPED variance reduction, sequential testing, Harbor Analytics SQL assistant case, technique decision table vs canary-only and offline eval, pitfalls, and checklist.
• LLM online evaluation explained: live quality monitoring, implicit signals and production feedback loops Measure LLM quality on real traffic — implicit and explicit feedback, stratified sampling, LLM-as-judge on live logs, drift detection, Harbor Support resolution-rate monitoring case, technique decision table vs offline-only eval and full human review, pitfalls, and checklist.
• LLM machine unlearning explained: forget sets, approximate removal and compliance Remove training data influence from model weights — exact vs approximate unlearning, gradient ascent and NPO methods, membership inference evaluation, Harbor Legal contract-memorization case, technique decision table vs retraining and RAG-only deletion, pitfalls, and checklist.
• LLM catastrophic forgetting and continual learning explained: replay, EWC and multi-adapter routing Why sequential fine-tuning erases old skills — plasticity-stability tradeoff, replay buffers and elastic weight consolidation, per-task LoRA routing, Harbor Legal NDA regression 91→71→89% case, technique decision table vs full retrain and RAG-only updates, pitfalls, and checklist.
• LLM data poisoning explained: training attacks, backdoors and supply-chain defenses Label flipping and trigger backdoors, instruction hijacking and RAG corpus attacks, lifecycle attack surfaces, detection signals, Harbor Analytics fraud-model refactor, technique decision table vs guardrails-only, pitfalls, and checklist.
• LLM distillation explained: teacher-student training, logits and production SLMs Knowledge distillation for language models — logits and hidden-state transfer, synthetic data pipelines, distillation vs fine-tuning vs quantization, Harbor Support intent classifier worked example, method decision table, pitfalls, and checklist.
• LLM interpretability explained: probing, attribution and mechanistic analysis Hidden-state probing, gradient and perturbation attribution, sparse autoencoders, activation patching and causal tracing, RAG chunk attribution, faithfulness pitfalls, Harbor Analytics refusal debugger worked example, method decision table, pitfalls, and checklist.
• LLM activation steering explained: representation engineering and inference-time control Contrastive steering vectors, activation addition and subtraction, layer hooks and coefficient tuning, multi-vector composition, Harbor Support empathy refactor, technique decision table vs prompts and fine-tuning, pitfalls, and checklist.
• LLM sparse autoencoders explained: mechanistic interpretability and monosemantic feature discovery Dictionary learning on residual-stream activations — reconstruction plus L1 sparsity, feature labeling and causal ablation, feature steering vs contrastive vectors, Harbor Safety deceptive-compliance audit 29→6%, technique decision table vs probing and activation steering, pitfalls, and checklist.
• LLM fill-in-the-middle explained: FIM training, PSM layout and IDE code completion Span-masking pretrain, prefix-suffix-middle token order, fim special tokens, serving infill in vLLM and IDEs, Harbor Analytics tab-completion refactor, technique decision table vs prefix-only completion, pitfalls, and checklist.
• Tree of Thoughts reasoning explained: search, backtracking and LLM planning Branching thought generation, state evaluation, BFS and DFS controllers, Harbor Support escalation refactor, technique decision table vs chain-of-thought and test-time compute, pitfalls, and checklist.
• LLM self-consistency reasoning explained: majority voting, sampling and accuracy Multiple chain-of-thought samples, plurality and weighted voting, answer extraction and normalization, Harbor Analytics fraud-scoring refactor, technique decision table vs tree search and verifiers, pitfalls, and checklist.
• LLM chain-of-verification explained: fact-checking loops, question planning and hallucination reduction Baseline answer, verification question planning, independent factored checks without the draft, revised final response, Harbor Support policy Q&A refactor, technique decision table vs RAG and self-consistency, pitfalls, and checklist.
• LLM self-refine explained: critique loops, iterative revision and quality improvement Draft-feedback-revise cycles, executable validators and model critics, Harbor Analytics SQL refactor, technique decision table vs chain-of-verification and self-consistency, pitfalls, and checklist.
• LLM Reflexion explained: verbal reinforcement, episodic memory and agent self-improvement Learn from trial failures without weight updates — actor-evaluator-reflect loops, scratchpad and vector episodic memory, Harbor Support deployment agent refactor, technique decision table vs self-refine and RLHF, pitfalls, and checklist.
• LLM plan-and-execute explained: planners, executors and multi-step agent pipelines Split strategic planning from tactical tool use — structured step lists, rolling horizons, replanning on failure, Harbor Legal due-diligence refactor, technique decision table vs ReAct and tree-of-thought, pitfalls, and checklist.
• LLM ReWOO explained: reasoning without observation, parallel tools and solver pipelines Planner-worker-solver split — evidence variables (#E1, #E2), parallel tool workers, solver synthesis with citations, Harbor Procurement vendor memo refactor 41→25 s p95 and 44% fewer input tokens, technique decision table vs ReAct and plan-and-execute, pitfalls, and checklist.
• LLM ReAct agent loop explained: thought, action, observation and production tool use Interleaved reasoning loop — thought-action-observation anatomy, scratchpad and facts-block design, action parsing and policy gates, Harbor Support refund refactor, technique decision table vs plan-and-execute, pitfalls, and checklist.
• LLM agent loop termination explained: stopping criteria, budget caps and production guardrails Max-iteration and token/cost governors, goal predicates and finish tools, stagnation and oscillation fingerprinting, graceful handoff, Harbor Analytics incident refactor, technique decision table vs open-ended ReAct, pitfalls, and checklist.
• LLM agent evaluation and benchmarking explained: trajectory scoring, tool metrics and regression suites Multi-step agent benchmarks — task success rate, tool selection and argument validity, sandbox golden tasks, trajectory judges, Harbor Analytics incident workflow 58→79% refactor, technique decision table vs single-turn eval, pitfalls, and checklist.
• LLM agent run audit trail and compliance logging explained: immutable events, attestations and regulatory replay Tamper-evident agent audit streams — hash-chained events, approval attestations, PII redaction, retention and legal hold, Harbor Finance SOX remediation 11→6 h refactor, decision table vs generic tracing, pitfalls, and checklist.
• LLM agent secrets and credential injection explained: vault brokers, scoped tokens and least-privilege tool access Keep API keys out of model context — credential broker pattern, runtime injection, scoped delegation tokens, tool ref schemas, trace redaction, Harbor Platform 14→0% secret leak refactor, decision table vs prompt env vars, pitfalls, and checklist.
• LLM agent cost attribution and token accounting explained: per-run budgets, tool metering and FinOps Attribute LLM spend to runs, tools, and tenants — run ledgers, span-level cost tags, subagent budget slices, tool surcharges, Harbor Support $12→$4.10/run refactor, decision table vs cloud invoices only, pitfalls, and checklist.
• LLM agent testing, mocking and E2E harness explained: record-replay, tool stubs and CI regression suites Agent test pyramid — unit FSM and policy tests, LLM cassettes and tool fakes, trajectory assertions, nightly live E2E slice, Harbor DevOps PR failure 38→4% refactor, decision table vs eval-only gates, pitfalls, and checklist.
• LLM agent deterministic replay and run reproducibility explained: record-replay, seeding and production debug Re-run production agent failures bit-for-bit — run manifests, LLM cassettes, tool stubs, clock and seed pinning, Harbor DevOps incident replay 73→94% reproducibility refactor, decision table vs trace-only debug, pitfalls, and checklist.
• LLM agent handoff and session transfer explained: warm transfer, state packages and channel continuity Production handoffs between bots, specialists, and humans — trigger rules, typed session transfer packages, warm vs cold transfer, voice-to-chat continuity, Harbor Support escalation 41→27% repeat-contact refactor, decision table vs chat dumps, pitfalls, and checklist.
• LLM agent planning and task decomposition explained: plan-act-verify, DAGs and replanning Multi-step agent goals as verifiable plans — upfront vs reactive planning, hierarchical task networks, structured plan schemas, checkpoint gates, Harbor DevOps 34→6% partial-failure refactor, decision table vs pure ReAct, pitfalls, and checklist.
• LLM agent cancellation, timeout and lifecycle management explained: cooperative shutdown, tool cleanup and run FSMs Production stop signals — user cancel vs policy timeout vs budget drain, cooperative vs forced shutdown, run state machines, tool compensations, subagent cascade, Harbor Platform 19→1.2% orphaned migration refactor, decision table vs hard kill, pitfalls, and checklist.
• LLM agent observability and tracing explained: spans, tool latency and production debug OpenTelemetry-style agent traces — ReAct step envelopes, tool latency and token attribution, PII redaction and sampling, trace replay into sandbox, Harbor Analytics MTTR 47→11 min refactor, technique decision table vs chat logs, pitfalls, and checklist.
• LLM durable agent execution and checkpointing explained: resume, idempotency and long-running workflows Production agent durability — checkpoint schemas, run state machines, idempotent tool ledgers, human approval pauses, Harbor Logistics vendor onboarding 23→0% duplicate side effects refactor, technique decision table vs in-memory ReAct, pitfalls, and checklist.
• LLM agent subagent delegation explained: context isolation, budgets and supervisor patterns Parent-child agent orchestration — spawn-and-wait vs parallel fan-out, typed result envelopes, permission scoping, parent-child trace trees, Harbor Analytics due-diligence 61→89% accuracy refactor, technique decision table vs monolithic ReAct, pitfalls, and checklist.
• LLM computer use and browser automation agents explained: vision loops, DOM tools and sandboxing Production UI control agents — screenshot vs accessibility-tree observation, set-of-mark grounding, typed browser action APIs, credential isolation, Harbor Insurance claims portal 62→91% accuracy refactor, decision table vs APIs and RPA, pitfalls, and checklist.
• LLM agent permission scoping and tool approval gates explained: least privilege, policy engines and production safety Production agent access control — capability manifests, session scopes, tiered approval gates, policy engines, Harbor Platform Engineering 11→0.3% unauthorized mutation refactor, decision table vs open tool catalogs, pitfalls, and checklist.
• LLM agent guardrails and output validation explained: schema gates, policy layers and production safety Runtime output validation before side effects — JSON Schema gates, semantic policy checks, validate-repair loops, block-and-escalate paths, Harbor Benefits 19→0.8% bad enrollment refactor, decision table vs prompt-only safety, pitfalls, and checklist.
• LLM agent hallucination detection and grounding verification systems explained: claim extraction, citation checks and safe answers Post-generation claim decomposition, evidence entailment judges, citation bijection, confidence gating profiles, Harbor Legal 41→3.1% unsupported-claim refactor, decision table vs RAG alone, pitfalls, and checklist.
• LLM agent adversarial input detection and ingress firewall systems explained: jailbreak classifiers, policy gates and safe intake Intake boundary defense — normalization, jailbreak and injection classifiers, attachment extract-and-scan, session reputation, READ_ONLY escalation, Harbor Portal 29→1.8% policy-bypass refactor, decision table vs output guardrails alone, pitfalls, and checklist.
• LLM agent PII detection and redaction pipeline systems explained: ingress scrubbing, token vaults and audit-safe traces Detect and redact regulated fields before they hit models, logs, and third-party tools — PII taxonomy, layered detectors, reversible vault tokens, pipeline placement, Harbor Benefits 23→0.2% CRM leak refactor, decision table vs prompt-only privacy, pitfalls, and checklist.
• LLM agent production feedback and correction loops explained: runtime capture, golden tests and continuous improvement Turn user corrections into durable agent quality — correction event schemas, inline-edit diffing, golden test promotion gates, stratified eval refresh, Harbor Legal 34→6% repeat-error refactor, decision table vs offline-only alignment, pitfalls, and checklist.
• LLM agent rate limiting and throttling explained: multi-layer quotas, token buckets and production backpressure Shape agent traffic before upstream 429s — provider TPM/RPM, per-tenant fairness, tool integration buckets, session caps, adaptive backoff, Harbor Commerce 22→0.4% cascade refactor, decision table vs hard caps, pitfalls, and checklist.
• LLM agent prompt caching systems explained: prefix reuse, cache keys and prefill cost control Reuse cached prompt prefixes across agent turns — static vs dynamic segmentation, provider cache breakpoints, TTL and invalidation, tenant isolation, Harbor Analytics 52% prefill savings refactor, decision table vs compression alone, pitfalls, and checklist.
• LLM agent prompt template versioning and rollout systems explained: semver registries, safe promotion and rollback Ship prompt changes without mixed-version pools — immutable semver registry, layered composition, shadow and canary promotion, cache invalidation, Harbor Compliance 39→2.4% policy-violation refactor, decision table vs code deploys alone, pitfalls, and checklist.
• LLM agent semantic caching and similar-query response reuse systems explained: embedding indexes, similarity gates and safe staleness Reuse answers for paraphrased questions without byte-identical queries — query normalization, per-tenant vector indexes, namespace versioning, freshness classes, Harbor Support 41→6.2% duplicate-generation refactor, decision table vs exact and prefix caches, pitfalls, and checklist.
• LLM agent session lifecycle and conversation thread management systems explained: thread FSMs, idle policies and resume tokens Bound multi-turn agent conversations with explicit session states — thread lineage, idle and archive FSMs, compaction triggers, signed resume tokens, Harbor Portal 38→7.4% repeat-contact refactor, decision table vs stateless chat, pitfalls, and checklist.
• LLM agent model fallback and graceful degradation explained: routing ladders, health gates and production resilience Survive provider outages without hard-failing agent runs — task-class routing ladders, capability matrices, circuit breakers, degradation tiers 0–3, Harbor Support 31→1.2% failure refactor, decision table vs single-model pinning, pitfalls, and checklist.
• LLM agent MCP tool server integration production systems explained: connection pools, capability registry and tenant-scoped auth Integrate Model Context Protocol servers at scale — warm stdio pools, versioned capability registry, run-scoped schema snapshots, tenant credential injection, circuit breakers, Harbor Platform 47→6.8% tool-timeout refactor, decision table vs spawn-per-call, pitfalls, and checklist.
• LLM agent model routing and intent classification systems explained: tier selection, cost-quality tradeoffs and production cascades Route each run to the right model tier — rules + ML intent classifiers, complexity scoring, tier matrices, mid-run escalation, Harbor Desk 52→18% overspend refactor, decision table vs single-model or fallback-only routing, pitfalls, and checklist.
• LLM agent canary deployment and shadow traffic systems explained: safe rollouts, metric gates and production cutover Ship new agent versions without burning users — shadow replay on production inputs, staged canary splits, promotion gates, auto-rollback triggers, Harbor Support 12→0.8% bad-deploy refactor, decision table vs big-bang releases, pitfalls, and checklist.
• LLM agent A/B test experiment assignment and traffic splitting systems explained: sticky buckets, variant bundles and safe rollouts Compare prompt and retrieval variants without incoherent multi-service splits — sticky bucketing, atomic variant manifests, mutual-exclusion groups, guardrail auto-pause, Harbor Insights 52→7.8% false-win refactor, decision table vs canary alone, pitfalls, and checklist.
• LLM agent feature flag and dynamic configuration systems explained: runtime toggles, layered overrides and safe kill switches Centralized config plane for agent ops — versioned snapshots, tenant overlays, run-start pinning, emergency kill switches, Harbor Platform 46→5.2% misconfiguration-incident refactor, decision table vs env-only deploys, pitfalls, and checklist.
• LLM agent retry, backoff and transient failure recovery explained: idempotency keys, budgets and safe retries Retry only transient failures without duplicate side effects — error taxonomy, exponential backoff with jitter, idempotency keys for write tools, per-step retry budgets, Harbor Logistics 28→1.1% duplicate-shipment refactor, decision table vs blind retry, pitfalls, and checklist.
• LLM agent idempotency key and request deduplication systems explained: ingress, queues and safe retries Stop duplicate webhooks and twin write tools from double-charging customers — four dedup layers, key canonicalization, pending/succeeded lifecycle, response replay, Harbor Payments 44→2.3% duplicate-refund refactor, decision table vs caching alone, pitfalls, and checklist.
• LLM agent inference batching and request coalescing systems explained: throughput, latency and FinOps Fill GPUs under bursty agent load — coalescing windows, continuous batching, priority lanes, streaming demux, Harbor Support 34→4.8% budget-breach refactor, decision table vs prompt caching alone, pitfalls, and checklist.
• LLM agent run priority queue and admission control systems explained: fair scheduling, SLA tiers and production backpressure Gate runs before work starts — P0–P3 priority lanes, weighted fair queuing, concurrency and token budgets, shed vs defer policies, Harbor Analytics 47→5.8% SLA-miss refactor, decision table vs rate limits alone, pitfalls, and checklist.
• LLM agent SLA and deadline enforcement systems explained: end-to-end latency budgets, tiered SLOs and graceful degradation Honor customer-facing latency contracts — deadline tokens, budget propagation across tools and subagents, soft vs hard cutoffs, partial streaming, Harbor Desk 51→6.4% SLA-miss refactor, decision table vs priority queues alone, pitfalls, and checklist.
• LLM agent circuit breaker and bulkhead resilience systems explained: failure isolation, shedding and production stability Stop retry storms from collapsing the fleet — per-dependency circuit breakers, bulkhead concurrency pools, half-open probes, degradation tiers, Harbor Platform 89→4% outage amplification refactor, decision table vs retry alone, pitfalls, and checklist.
• LLM agent RAG retrieval pipeline systems explained: query routing, hybrid search and grounded tool loops Ground agents in live knowledge — retrieval triggers, query rewriting, hybrid dense+sparse search, cross-encoder reranking, citation contracts, Harbor Legal 52→7% unsupported-claim refactor, decision table vs prompt stuffing, pitfalls, and checklist.
• LLM agent tool call parsing and validation production systems explained: schema gates, repair loops and safe execution Turn model output into safe tool invocations — native vs text extraction, streaming fragment assembly, JSON Schema gates, argument sanitization, bounded repair loops, Harbor Ops 38→4.2% parse-failure refactor, decision table vs trust-the-model, pitfalls, and checklist.
• LLM agent tool error handling and partial failure recovery explained: structured envelopes, batch semantics and safe continuation Stop agents from claiming success when tools fail — structured error envelopes, partial-batch policies, recovery matrix, Harbor Integrations 34→2.4% silent-failure refactor, decision table vs raw stack traces, pitfalls, and checklist.
• LLM agent dynamic tool selection and routing explained: registry design, intent routers and context-efficient exposure Scale agents past static tool lists — capability registries, permission filters, hybrid embedding retrieval, taxonomy routing, Harbor Platform 38→4.2% wrong-tool refactor, decision table vs expose-all, pitfalls, and checklist.
• LLM agent reflection and self-critique verification loops explained: draft-critic pipelines, verifier gates and safe iteration Catch agent errors before users see them — self-refine vs draft-critic vs CoVe, deterministic span verifiers, iteration budgets, Harbor Compliance 29→3.1% citation-error refactor, decision table vs single-pass, pitfalls, and checklist.
• LLM agent sandbox code execution systems explained: isolation, resource limits and safe tool runtimes Run model-generated code without handing it your API keys — microVM and gVisor tiers, deny-all egress, ephemeral workspaces, stdout redaction, Harbor Analytics 19→0.3% credential-exposure refactor, decision table vs host exec, pitfalls, and checklist.
• LLM agent streaming response delivery systems explained: SSE, token deltas and live progress Show work while tools run, not only while tokens decode — typed SSE envelopes, tool progress frames, backpressure, reconnect replay, Harbor Support 34→6% abandon refactor, decision table vs blocking JSON, pitfalls, and checklist.
• LLM agent multi-tenancy and tenant isolation systems explained: namespaces, quotas and data boundaries Serve many customers from one agent cluster without cross-tenant leaks — tenant context propagation, RLS and vector namespaces, sandbox and secret scoping, quota envelopes, Harbor Platform 3.2→0% cross-tenant refactor, decision table vs dedicated stacks, pitfalls, and checklist.
• LLM agent webhook and async job queue systems explained: ingress, dedup and durable triggers Trigger agents from Zendesk, GitHub and Stripe without duplicate side effects — signature verification, idempotency keys, queue topology, tenant binding on workers, delayed jobs, Harbor Integrations 41→3% duplicate-run refactor, decision table vs sync HTTP, pitfalls, and checklist.
• LLM agent outbound webhook and callback delivery systems explained: signing, retries and at-least-once guarantees Notify customers when async runs finish — subscription registry, signed event envelopes, delivery queues, exponential backoff, stable event IDs, Harbor Fulfillment 37→4.1% missed-callback refactor, decision table vs polling, pitfalls, and checklist.
• LLM agent scheduled cron job trigger systems explained: time-based runs, missed-window policy and safe catch-up Fire agents on calendar schedules without duplicate closes — versioned registry, IANA timezone and DST rules, skip vs coalesce missed ticks, overlap guards, per-tick idempotency, Harbor Finance 19→0.6% duplicate-close refactor, decision table vs webhook-only, pitfalls, and checklist.
• LLM agent file upload and attachment ingestion pipeline systems explained: validation, parsing and safe context injection Let users attach PDFs, images and audio without blowing context or leaking PII — presigned quarantine uploads, magic-byte validation, parse routing by media type, chunk budgets, Harbor Legal 27→1.4% attachment-error refactor, decision table vs paste-only, pitfalls, and checklist.
• LLM agent dead letter queue and poison message handling systems explained: triage, replay and safe recovery Isolate failing agent jobs without starving the queue — failure taxonomy, retry budgets, side-effect ledgers, checkpoint-aware replay, Harbor Compliance 61→2% poison-outage refactor, decision table vs infinite retry, pitfalls, and checklist.
• LLM agent human-in-the-loop escalation and approval workflow systems explained: review queues, timeouts and safe resume Pause agent runs for human judgment on high-risk actions — escalation triggers, approval packets, reviewer UX, timeout delegation, Harbor Legal 19→0.4% unauthorized outbound refactor, decision table vs full automation, pitfalls, and checklist.
• LLM agent durable state, checkpointing and run persistence explained: crash recovery, resume and long-running workflows Survive deploys and pod deaths without losing hours of agent work — WAL event logs, periodic snapshots, resume tokens and leases, idempotent replay, Harbor Research 41→2.8% abandoned-run refactor, decision table vs in-memory only, pitfalls, and checklist.
• LLM agent tool result caching systems explained: exact keys, TTL classes and safe staleness Stop reflection loops from re-fetching the same ticket eight times — cache key design, freshness classes, in-run vs cross-run tiers, webhook invalidation, Harbor Integrations 62→8% duplicate API call refactor, decision table vs prompt caching, pitfalls, and checklist.
• LLM agent tool result summarization and truncation explained: observation budgets, structured projection and safe compression Shrink oversized tool payloads before they blow the context window — per-tool observation caps, JSON path projection, head/tail truncation, inline summarization, pagination cursors, Harbor DevOps 38k→4.2k token refactor, decision table vs raw payloads, pitfalls, and checklist.
• LLM agent middleware hook pipeline explained: composable pre/post hooks, cross-cutting policy and production ordering Wire guardrails, AuthZ, redaction, and observability once — ordered pre/post model and tool hooks, short-circuit gates, Harbor Platform 14→0% secret-leak refactor, decision table vs monolithic handlers, pitfalls, and checklist.
• LLM tool error handling explained: structured observations, retries and agent recovery Tool-side error taxonomy, JSON observation envelopes, idempotent retry gates, alternate-tool fallbacks, Harbor Logistics shipment refactor, technique decision table vs blind retry, pitfalls, and checklist.
• LLM agent parallel tool execution explained: dependency graphs, concurrency caps and safe batching Parallel vs serial tool runs — read vs write safety gates, DAG wave scheduling, per-integration caps, partial failure envelopes, Harbor DevOps 47→12 s step latency refactor, decision table vs serial execution, pitfalls, and checklist.
• LLM agent compensating transactions and saga rollbacks explained: multi-step undo, partial failure recovery and side-effect reversal Saga orchestration for agent workflows — compensating tool pairs, runtime idempotency keys, irreversible step gates, Harbor Finance 31→2% orphan side-effect refactor, decision table vs blind retry, pitfalls, and checklist.
• LLM tool schema design explained: JSON Schema, parameter descriptions and production tool APIs JSON Schema structure, parameter naming and enum patterns, granularity tradeoffs, server-side validation, Harbor Support refund bot refactor, technique decision table vs unstructured prompts, pitfalls, and checklist.
• LLM dynamic tool selection explained: retrieval, routing and context budgets for large tool catalogs Embedding retrieval over tool registries, intent bundles and top-k pruning, session allowlists and pinned core tools, Harbor Support enterprise MCP catalog refactor, technique decision table vs full-catalog exposure, pitfalls, and checklist.
• LLM tool result compression explained: observation budgets, summarization and agent context Schema projection, stratified truncation, typed aggregates and external handles, per-tool observation caps, Harbor Analytics log-query refactor, technique decision table vs raw observation dumps, pitfalls, and checklist.
• LLM parallel tool calling explained: concurrent functions, DAG scheduling and agent latency Independence taxonomy, native multi-tool-call APIs, bounded concurrency and rate limits, partial-failure observation merge, Harbor Support triage refactor, technique decision table vs serial ReAct, pitfalls, and checklist.
• LLM refusal behavior explained: policy refusals, over-refusal and calibration Refusal taxonomy, over-refusal vs under-refusal tradeoffs, layered enforcement with guardrails and classifiers, calibration metrics and eval sets, Harbor Support policy bot refactor, technique decision table vs blocklists-only, pitfalls, and checklist.
• LLM fine-tuning vs RAG explained: when to train, when to retrieve Knowledge freshness and provenance tradeoffs, cost and latency, hybrid LoRA-plus-corpus patterns, Harbor Legal contract assistant refactor, technique decision table vs fine-tune everything, pitfalls, and checklist.
• LLM embedding quantization explained: INT8, product quantization and RAG index sizing Scalar INT8, float16, product quantization, binary vectors, Matryoshka truncation, ANN recall tradeoffs, Harbor Support vector index refactor, technique decision table vs full-precision storage, pitfalls, and checklist.
• LLM embedding fine-tuning explained: domain adaptation, contrastive training and RAG retrieval Contrastive objectives, query-document pairs, hard negative mining, LoRA adapters, recall@k and MRR eval, Harbor Support retrieval refactor, technique decision table vs off-the-shelf embeddings and rerankers, pitfalls, and checklist.
• LLM ambiguous query clarification explained: when to ask, disambiguation gates and RAG safety Pre-synthesis disambiguation — entity/scope/metric ambiguity taxonomy, retrieval score clustering and metadata entropy gates, closed-choice clarifiers, multi-turn filter routing, Harbor Analytics dashboard refactor, technique decision table vs answer-first RAG, pitfalls, and checklist.
• LLM intent classification and query routing explained: pipelines, confidence gates and production patterns Intent taxonomy, rule and embedding classifiers, RAG vs tool vs FAQ routing, confidence abstain bands, Harbor Support triage refactor, technique decision table vs one-pipeline-for-all, pitfalls, and checklist.
• LLM few-shot learning explained: exemplars, prompt design and when to fine-tune Zero/one/few-shot taxonomy, exemplar curation and ordering, delimiter patterns, token budget tradeoffs, Harbor Legal clause extractor refactor, technique decision table vs fine-tuning, pitfalls, and checklist.
• LLM context compression explained: summarization, token budgets and long-document pipelines Extractive selection, hierarchical map-reduce, conversation pruning, learned prompt compressors, Harbor Legal contract review refactor, technique decision table vs RAG and giant-context models, pitfalls, and checklist.
• LLM chain-of-density summarization explained: progressive entity-rich briefs at fixed word counts Sparse-to-dense iteration loop, missing-entity scoring, faithfulness gates, Harbor Media earnings brief refactor, technique decision table vs one-shot abstractive summaries, pitfalls, and checklist.
• LLM lost in the middle explained: U-shaped attention, context placement and RAG Primacy and recency bias in long prompts, needle-in-haystack recall curves, rerank-and-sandwich RAG layout, Harbor Legal indemnity-cap refactor, technique decision table vs giant windows, pitfalls, and checklist.
• LLM long context vs RAG explained: when to stuff the prompt vs retrieve selectively Capacity vs selection vs freshness — full-doc paste, top-k stuffing, hybrid RAG layouts, cost and prefill math, Harbor Analytics policy-bot refactor, technique decision table vs map-reduce and compression, pitfalls, and checklist.
• LLM RAG multi-hop retrieval explained: bridge entities, sub-questions and iterative search Cross-document QA — bridge-entity retrieval, decomposed sub-question pipelines, iterative read-and-search loops, graph-augmented hops, Harbor Engineering onboarding bot refactor, technique decision table vs single-shot and agentic RAG, pitfalls, and checklist.
• LLM FLARE active retrieval explained: generation-time search, uncertainty triggers and forward-looking queries Mid-generation RAG — token confidence pauses, forward-looking retrieval queries from partial drafts, chunk dedup and context injection, Harbor Engineering onboarding bot refactor, technique decision table vs single-shot and multi-hop RAG, pitfalls, and checklist.
• LLM reciprocal rank fusion explained: hybrid retrieval, score-free rank merging and RAG recall BM25 + dense + SPLADE list merging — RRF formula and k constant, per-list weights, dedup by chunk ID, Harbor Support KB recall@10 refactor, technique decision table vs weighted linear fusion and cross-encoder rerank, pitfalls, and checklist.
• LLM HyDE explained: hypothetical document embeddings, zero-shot dense retrieval and RAG recall Answer-shaped LLM passages as dense search probes — prompt templates, multi-HyDE RRF with BM25, Harbor Support recall@10 58→81% on acronym tickets, technique decision table vs multi-query expansion, pitfalls, and checklist.
• LLM contextual compression for RAG explained: query-aware chunk filtering, extractors and token budgets Post-retrieval query-aware pruning — embedding filters, LLM extractors, rerank-then-compress pipelines, Harbor Support faithfulness 62→84% with 74% fewer stuffed tokens, technique decision table vs reranking and parent-child chunking, pitfalls, and checklist.
• LLM step-back prompting explained: principle questions, abstraction ladders and RAG recall Pre-retrieval abstraction — principle question generation, dual-query RRF fusion, CoT scratchpad integration, Harbor Analytics physics QA recall@10 51→76%, technique decision table vs HyDE and multi-query expansion, pitfalls, and checklist.
• LLM Graph RAG explained: knowledge graphs, community summaries and global search Entity-relation extraction, Leiden community detection, local vs global search routing, Harbor Legal cross-contract QA recall@10 47→78%, technique decision table vs flat chunk RAG and multi-hop, pitfalls, and checklist.
• LLM RAPTOR hierarchical retrieval explained: tree summaries, clustered abstraction and multi-level search Recursive clustering and abstractive summarization, collapsed-tree retrieval across leaf and summary nodes, Harbor Analytics thematic recall@10 54→83%, technique decision table vs flat RAG and Graph RAG, pitfalls, and checklist.
• LLM map-reduce document processing explained: long-context summarization, hierarchical collapse and QA Map-phase chunk extraction, reduce-phase synthesis, recursive tree collapse, Harbor Legal merger-review refactor, technique decision table vs single-pass and RAG-only, pitfalls, and checklist.
• LLM PDF document parsing explained: layout analysis, table extraction and RAG ingest Born-digital vs scanned PDF pipelines, reading-order reconstruction, table and figure extraction, OCR fallbacks, Harbor Legal contract-ingest refactor, technique decision table vs plain text dump, pitfalls, and checklist.
• LLM RAG table extraction explained: serialization, chunking and numeric QA Detect and index tables for RAG — markdown vs HTML serialization, row-level chunks with header propagation, multi-page continuation, SQL sidecar routing, Harbor Finance earnings refactor, technique decision table vs prose-only ingest, pitfalls, and checklist.
• LLM logprobs and logit bias explained: confidence, classification and API control Token probability distributions, top-logprobs for closed-vocabulary classification, logit bias steering without fine-tuning, Harbor Legal contract triage refactor, technique decision table vs temperature-only sampling, pitfalls, and checklist.
• LLM conversation history management explained: summarization, truncation and token budgets Sliding windows vs rolling summaries, facts blocks and hybrid assembly, token budget slices, Harbor Support refund-thread refactor, technique decision table vs agent memory and compression, pitfalls, and checklist.
• LLM grammar-constrained decoding explained: logit masking, CFGs and valid JSON at generation time Finite-state and CFG constraints, JSON Schema token masking, Outlines and llguidance integrations, Harbor Commerce order parser refactor, technique decision table vs JSON mode and repair loops, pitfalls, and checklist.
• LLM program-aided language explained: code generation, sandboxes and reliable math PAL pattern — LLMs write executable Python instead of doing arithmetic in tokens, sandbox isolation and import allowlists, sympy and pandas helpers, Harbor Analytics portfolio stress-test refactor, technique decision table vs chain-of-thought and function calling, pitfalls, and checklist.
• LLM sandbox execution explained: isolated code runners, resource limits and production safety Container and WASM isolation for untrusted model-generated code — CPU and memory governors, network egress policy, import allowlists, Harbor Analytics PAL refactor, technique decision table vs in-process eval, pitfalls, and checklist.
• LLM mixture of agents explained: layered proposers, aggregators and collective reasoning MoA inference stacks — parallel heterogeneous proposers, aggregator synthesis and multi-layer refinement, Harbor Support policy Q&A refactor, technique decision table vs self-consistency and debate, pitfalls, and checklist.
• LLM multi-agent debate explained: adversarial rounds, fact-checking and moderator judges Proponent-critic debate loops — rebuttal rounds, evidence-grounded citations, stopping rules and judge verdicts, Harbor Analytics fraud cascade refactor, technique decision table vs mixture-of-agents and chain-of-verification, pitfalls, and checklist.
• LLM human-in-the-loop explained: review queues, approval gates and feedback pipelines HITL for production LLMs — confidence routing, async review queues, preference capture for RLHF, copilot vs autonomous send, Harbor Support triage refactor, technique decision table vs guardrails and full automation, pitfalls, and checklist.
• LLM confidence calibration and uncertainty explained: logprobs, abstention and routing Calibrated uncertainty for generative models — token logprobs vs verbalized confidence, semantic entropy and self-consistency disagreement, selective abstention, Harbor Analytics fraud-scoring refactor, technique decision table vs HITL and conformal prediction, pitfalls, and checklist.
• LLM canary and shadow deployment explained: safe model rollouts, traffic splitting and rollback Production LLM release patterns — shadow inference on live traffic, gated canary ramps with sticky sessions, blue-green cutovers, versioned prompts and retrieval snapshots, Harbor Support triage rollout refactor, technique decision table vs direct cutover and A/B tests, pitfalls, and checklist.
• LLM streaming responses explained: SSE, TTFT, backpressure and client patterns Token-by-token delivery for chat UIs — Server-Sent Events vs WebSocket, time-to-first-token SLOs, proxy buffering pitfalls, flush cadence, abort propagation, partial tool-call JSON, Harbor Support chat refactor, technique decision table vs blocking APIs, pitfalls, and checklist.
• LLM retry, fallback and resilience explained: backoff, circuit breakers and model chains Keeping LLM apps up during provider outages — error taxonomy, exponential backoff with jitter, idempotency keys, timeout budgets, model fallback chains, circuit breakers, Harbor Legal contract review refactor, technique decision table vs single-provider hope, pitfalls, and checklist.
• LLM async batch API explained: JSONL jobs, 50% discounts and overnight pipelines Offline LLM workloads at scale — provider batch endpoints, JSONL input/output format, 24-hour completion windows, per-line partial failures, cost discounts vs realtime sync, Harbor Analytics nightly backfill refactor, technique decision table vs streaming APIs, pitfalls, and checklist.
• LLM rate limiting and quota management explained: TPM, RPM and fair queues Surviving provider TPM and RPM ceilings — dual token buckets, gateway admission control, P0/P1/P2 priority lanes, multi-tenant budgets, Harbor Support triage refactor, technique decision table vs batch APIs and blind retries, pitfalls, and checklist.
• LLM prompt chaining explained: sequential pipelines, state passing and production gates Multi-step LLM workflows — linear, map-reduce and router topologies, typed state between links, validation gates, Harbor Legal contract review refactor, technique decision table vs monolithic prompts and ReAct loops, pitfalls, and checklist.
• LLM prompt versioning and registry explained: git, eval gates and rollback Production prompt management — artifact taxonomy, immutable semver, git vs DB vs vendor registries, environment pins, eval gates before promotion, Harbor Legal contract review refactor, technique decision table vs hard-coded strings, pitfalls, and checklist.
• LLM PII detection and redaction explained: pipelines, NER and surrogate tokens Production PII hygiene — entity taxonomy, regex vs NER vs classifiers, ingress and egress placement, reversible surrogate tokens, Harbor Analytics fraud pipeline refactor, technique decision table vs blind trust, pitfalls, and checklist.
• LLM content moderation and toxicity filters explained: classifiers, thresholds and appeals Production policy enforcement — hate and harassment taxonomy, blocklists vs classifier models, ingress and streaming egress placement, threshold bands and HITL appeals, Harbor Support chat refactor, technique decision table vs guardrails-only, pitfalls, and checklist.
• LLM output parsing and validation explained: JSON repair, schema gates and production pipelines Production parse hygiene — format taxonomy, fence stripping, schema and semantic validation layers, repair loops, streaming partial JSON, Harbor Legal contract refactor, technique decision table vs blind JSON.parse, pitfalls, and checklist.
• LLM text-to-SQL explained: schema grounding, safe query generation and NL2SQL pipelines NL2SQL taxonomy, schema linking and RAG over DDL, validation and EXPLAIN gates, read-only sandboxes, Harbor Analytics BI refactor, technique decision table vs prompt-and-run, pitfalls, and checklist.
• LLM reasoning models explained: hidden chain of thought, o1-style training and inference Reasoning-native LLMs — hidden thinking tokens, RL on verifiable rewards, thinking budgets and API serving, Harbor Analytics fraud-scoring cascade refactor, technique decision table vs CoT and test-time compute, pitfalls, and checklist.
• LLM query expansion for retrieval explained: multi-query, HyDE and RAG recall RAG query rewriting — multi-query paraphrase, HyDE hypothetical documents, step-back and decomposition, reciprocal rank fusion and reranking, Harbor Legal contract search refactor, technique decision table vs hybrid search and agentic RAG, pitfalls, and checklist.
• Small language models explained: Phi, Gemma, edge LLMs and model cascades Sub-10B parameter transformers — data-quality training, Phi and Gemma families, on-device deployment, cascade routing with frontier LLMs, Harbor Support triage router worked example, architecture decision table, pitfalls, and checklist.
• Ollama fundamentals explained: local LLMs, Modelfiles and OpenAI-compatible APIs Install and serve quantized models on laptop or server — pull, Modelfiles, REST and OpenAI-compatible endpoints, GPU VRAM planning, Harbor Support on-prem triage router worked example, tooling decision table, pitfalls, and checklist.
• LiteLLM fundamentals explained: multi-provider gateway, proxy and cost controls Unified Python SDK and OpenAI-compatible proxy for 100+ LLM vendors — completion calls, fallbacks, load balancing, budgets, semantic caching, Harbor Analytics multi-provider gateway worked example, tooling decision table, pitfalls, and checklist.
• vLLM fundamentals explained: PagedAttention, continuous batching and high-throughput inference Production LLM serving engine — PagedAttention KV cache, continuous batching, OpenAI-compatible API server, tensor parallelism, offline batch jobs, Harbor Analytics chat gateway worked example, inference stack decision table, pitfalls, and checklist.
• LLM continuous batching explained: iteration-level scheduling, throughput and latency Static vs iteration-level batching — prefill and decode phases, PagedAttention memory pools, scheduler policies and vLLM knobs, Harbor Analytics gateway refactor, technique decision table vs static batching, pitfalls, and checklist.
• LLM chunked prefill explained: token budgets, TTFT and mixed-batch scheduling Monolithic vs chunked prefill — prefill/decode interference, max_num_batched_tokens chunk ceilings, vLLM enable_chunked_prefill, Harbor Analytics RAG gateway refactor, technique decision table vs disaggregated prefill, pitfalls, and checklist.
• LLM admission control explained: request queues, backpressure and SLO-aware shedding Gateway queue policies — concurrency and token budgets, FIFO vs priority vs WFQ, wait-time shedding, Harbor Analytics Black Friday refactor, technique decision table vs rate-limit-only, pitfalls, and checklist.
• LLM tensor parallelism for inference explained: multi-GPU sharding, all-reduce and latency tradeoffs Megatron-style layer sharding — column vs row splits, all-reduce per token step, TP degree sizing vs batch size, vLLM tensor_parallel_size, Harbor Analytics 70B refactor, technique decision table vs pipeline or data parallel, pitfalls, and checklist.
• LLM pipeline parallelism for inference explained: stage sharding, micro-batches and bubble tradeoffs Vertical layer staging — micro-batch scheduling, pipeline bubble math, PP vs TP at batch 1 vs batch 64, vLLM pipeline_parallel_size, Harbor Analytics 405B batch refactor, technique decision table vs tensor-only serving, pitfalls, and checklist.
• LLM data parallel inference explained: replica scaling, load balancing and throughput Full model replicas — session stickiness, least-in-flight routing, DP vs TP scaling, vLLM multi-replica deployment, Harbor Analytics chat gateway refactor, technique decision table vs shard-only scaling, pitfalls, and checklist.
• LLM inference warmup and cold start explained: model loading, CUDA graphs and first-token latency Weight load and NVMe cache, CUDA kernel and graph warmup, readiness vs liveness probes, blue/green rollout, vLLM bucket pre-warm, Harbor Analytics deploy refactor, technique decision table vs TCP-only health checks, pitfalls, and checklist.
• LLM inference SLO and capacity planning explained: TTFT, throughput and GPU headroom TTFT and inter-token latency SLOs, tokens per second vs queue wait, Little’s law concurrency, KV memory budgeting, autoscaling signals, Harbor Analytics Black Friday refactor, technique decision table vs util-only sizing, pitfalls, and checklist.
• Gradio fundamentals explained: ML demos, Blocks API and Hugging Face Spaces Python UI framework for ML demos — Interface and Blocks APIs, ChatInterface for LLMs, queuing and auth, multimodal components, Hugging Face Spaces deployment, Harbor Support ticket triage UI worked example, tooling decision table, pitfalls, and checklist.
• Streamlit fundamentals explained: dashboards, session state and data apps Python framework for interactive data dashboards — widgets and rerun semantics, session state and forms, cache_data and cache_resource, layouts and multipage apps, charts and dataframes, Community Cloud and Docker deployment, Harbor Analytics revenue dashboard worked example, tooling decision table, pitfalls, and checklist.
• LLM model routing explained: cascades, classifiers and cost-quality tradeoffs Rule-based and learned routers, waterfall and parallel cascades, confidence gates and escalation, specialist model pools, latency budgets, Harbor Support multi-tier router worked example, routing pattern decision table, pitfalls, and checklist.
• 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 KV cache compression and eviction explained: H2O, StreamingLLM and long-context memory Shrink KV footprint at long context — FP8 precision, attention sinks, sliding windows, H2O heavy-hitter eviction, SnapKV prefix clustering, Harbor Analytics long-RAG refactor, technique decision table vs full-context serving, pitfalls, and checklist.
• LLM KV cache offloading explained: GPU, CPU and tiered memory for long context Spill paged KV blocks to pinned CPU DRAM when VRAM fills — block migration, PCIe bandwidth limits, vLLM swap_space, prefix/tail pinning policies, Harbor Analytics tiered-memory refactor, technique decision table vs compression only, pitfalls, and checklist.
• LLM speculative decoding explained: draft models, acceptance sampling and faster inference Accelerate autoregressive decode with draft-and-verify speculation — acceptance rate math, Eagle and Medusa heads, vLLM speculative config, batching interaction, Harbor Support chat gateway refactor, technique decision table vs CUDA graphs only, pitfalls, and checklist.
• LLM RoPE scaling and positional encoding explained: YaRN, NTK and long-context extension Extend context beyond pretraining — RoPE fundamentals, PI and NTK scaling, YaRN and LongRoPE, ALiBi alternatives, Harbor Legal contract-review refactor, technique decision table vs KV-only fixes, pitfalls, and checklist.
• LLM PagedAttention explained: KV block pools, memory fragmentation and vLLM serving Fixed-size KV blocks and logical-to-physical block tables, memory pool sizing and admission math, pairing with continuous batching, Harbor Analytics OOM refactor, technique decision table vs contiguous allocation, pitfalls, and checklist.
• LLM attention sinks explained: streaming context, initial tokens and long-sequence inference Initial-token sink phenomenon, StreamingLLM eviction, sink tokens vs sliding windows, Harbor Support chat gateway refactor, technique decision table vs naive KV truncation, pitfalls, and checklist.
• 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 CUDA graphs for decode inference explained: kernel launch overhead, shape buckets and throughput CUDA graph capture and replay on autoregressive decode — batch-size buckets, pairing with continuous batching and PagedAttention, vLLM configuration, Harbor Analytics decode refactor, technique decision table vs eager mode, pitfalls, and checklist.
• LLM serving prefix cache and RadixAttention explained: cross-request KV reuse on self-hosted GPUs Inference-engine prefix trees — RadixAttention and vLLM automatic prefix caching, block pool sharing, hit-rate metrics, eviction and pinning policies, Harbor Analytics multi-tenant RAG refactor, technique decision table vs API prompt cache only, pitfalls, and checklist.
• LLM semantic caching explained: similarity hits, cost savings and production patterns Paraphrase-tolerant query cache — embedding similarity thresholds, hit and miss flows, TTL and invalidation, GPTCache and Redis patterns, Harbor Support FAQ router worked example, approach decision table, pitfalls, and 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 benchmark contamination explained: data leakage, decontamination and honest eval When public benchmark scores lie — pretraining overlap, n-gram decontamination, perplexity probes, private golden sets, Harbor Analytics model selection refactor, technique decision table vs headline MMLU, pitfalls, and checklist.
• LLM-as-judge explained: rubrics, bias mitigation and automated quality scoring Pointwise vs pairwise judging, rubric design and anchor examples, position and leniency bias, RAG faithfulness scoring, calibration against human labels, Harbor Support eval pipeline worked example, method decision table, pitfalls, and checklist.
• 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.
• LoRA fine-tuning explained: low-rank adapters, QLoRA and production deployment Low-rank matrix decomposition on frozen transformers — rank and alpha tuning, target modules, QLoRA 4-bit training, merge vs sidecar adapters, Harbor Support tone adapter worked example, method decision table, pitfalls, and checklist.
• QLoRA explained: 4-bit quantized LoRA fine-tuning on a single GPU NF4 backbone storage, double quantization, paged AdamW optimizers, memory breakdown vs bf16 LoRA, Harbor Analytics 13B SQL adapter 71→94% execution accuracy, technique decision table vs full fine-tuning, pitfalls, and checklist.
• DoRA explained: weight-decomposed low-rank adaptation for LLM fine-tuning Magnitude-direction decomposition beyond LoRA — learnable row scales plus low-rank direction updates, QDoRA 4-bit training, Harbor Legal clause-QA 74→86% at rank 16, technique decision table vs LoRA and full fine-tuning, pitfalls, and checklist.
• LLM multi-LoRA serving explained: dynamic adapters, batch scheduling and vLLM configuration One base model, dozens of tenant adapters — registry routing, max_loras and lora_modules, heterogeneous batch penalties, Harbor Analytics gateway refactor, technique decision table vs merged replicas, pitfalls, and checklist.
• LLM knowledge editing explained: ROME, MEMIT and surgical fact updates Patch specific facts in model weights without full retraining — locate-then-edit, rank-one MLP updates, batch MEMIT, hypernetwork editors, efficacy and specificity metrics, Harbor Support policy refactor, technique decision table vs RAG and fine-tuning, pitfalls, and checklist.
• LLM model merging explained: SLERP, TIES, LoRA fusion and task arithmetic Combine fine-tuned checkpoints without retraining — linear and spherical interpolation, TIES and DARE conflict resolution, LoRA adapter fusion, MergeKit workflows, Harbor Support multi-skill merge worked example, method decision table, pitfalls, and checklist.
• LLM observability explained: traces, token metrics, RAG debugging and production monitoring Chain and agent tracing, prompt logging with PII redaction, token and cost dashboards, RAG retrieval visibility, production quality sampling, LangSmith and OpenTelemetry patterns, Harbor Support ops dashboard worked example, tooling decision table, pitfalls, and checklist.
• LLM multi-tenant isolation explained: quotas, noisy neighbors and secure shared inference Per-tenant API keys and rate limits, TPM and concurrency caps, weighted fair queuing, latency vs throughput pools, cache and log partitioning, Harbor Analytics gateway refactor, technique decision table vs single shared pool, pitfalls, and checklist.
• 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.
• LLM red teaming explained: adversarial testing, attack libraries and safety evals Threat modeling, manual and automated attack campaigns, jailbreak libraries, agent and RAG abuse surfaces, severity scoring and ASR metrics, Harbor Support purple-team worked example, method decision table, pitfalls, and checklist.
• LLM prompt injection defense explained: direct attacks, RAG poisoning and production mitigations Injection taxonomy (direct, indirect, tool-mediated), instruction hierarchy and context fencing, least-privilege tool gates, RAG corpus hygiene and document sanitization, output validation, Harbor Support refund-agent refactor, technique decision table vs moderation-only, pitfalls, and checklist.
• 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.
• Context engineering explained: assembling LLM prompts, RAG and agent memory System prompts, retrieved chunks, tool schemas, conversation history and memory tiers, token budgeting, lost-in-the-middle placement, Harbor Support agent context stack worked example, approach decision table, pitfalls, and checklist.
• In-context learning explained: demonstrations, prompt adaptation and when not to fine-tune How LLMs learn tasks from labeled examples in the prompt — format consistency, label bias, example ordering, ICL vs fine-tuning vs RAG, Harbor Support ticket router worked example, approach decision table, pitfalls, and checklist.
• 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.
• Attention mechanism explained: query, key, value and scaled dot-product attention The core lookup behind transformers — Q/K/V projections, softmax weights, self vs cross-attention, multi-head design, positional encoding, O(n²) cost, Flash Attention, interpretability traps, and a practitioner checklist.
• Flash Attention explained: IO-aware attention, memory savings and LLM speedups Why attention is HBM-bound — tiled SRAM kernels, online softmax, FlashAttention-2 parallelism, PyTorch SDPA integration, Harbor LLM prefill worked example, decision table, pitfalls, and checklist.
• Sliding window attention explained: local context, long sequences and LLM memory Banded causal masks and O(n×w) attention — ring-buffer KV eviction, stacked-layer receptive fields, Mistral and Gemma patterns, Harbor Support long-doc RAG refactor, technique decision table, pitfalls, and checklist.
• Rotary position embeddings (RoPE) explained: relative position, context length and LLM extrapolation How RoPE rotates Q and K in 2D subspaces — relative position property, base frequency and NTK/YaRN scaling, Harbor Support RAG context extension refactor, positional scheme decision table, pitfalls, and checklist.
• Gradient checkpointing explained: activation checkpointing, memory tradeoffs and LLM fine-tuning Trade compute for GPU memory during training — activation storage, per-layer checkpointing, PyTorch and Hugging Face APIs, pairing with mixed precision and Flash Attention, Harbor Analytics 13B fine-tune refactor, technique decision table, pitfalls, and checklist.
• Speculative decoding explained: draft models, acceptance sampling and LLM throughput Speed decode without changing output distributions — draft-and-verify loops, rejection sampling math, Medusa and EAGLE lookahead, draft model pairing, Harbor Support chat gateway refactor, technique decision table, pitfalls, and checklist.
• LLM prefill-decode disaggregation explained: split serving, KV transfer and throughput Separate compute-bound prefill from memory-bound decode — split GPU pools, KV cache handoff over NVLink and RDMA, SGLang and vLLM patterns, prefix-aware routing, Harbor Support RAG gateway refactor, architecture decision table, pitfalls, and checklist.
• Distributed LLM training explained: data parallelism, FSDP, tensor and pipeline parallel Multi-GPU training axes — DDP, tensor and pipeline parallelism, FSDP and DeepSpeed ZeRO stages, 3D parallelism and expert parallel, Harbor Analytics 13B fine-tune refactor, technique decision table, pitfalls, and checklist.
• LLM knowledge distillation explained: teacher-student training, soft labels and model compression Teacher-student objectives — temperature-scaled soft labels, response and hidden-state distillation, self-distillation and on-policy variants, Harbor Analytics support-bot refactor, technique decision table vs quantization-only and fine-tuning-only, pitfalls, and checklist.
• Group Query Attention (GQA) explained: MQA, KV cache savings and LLM inference MHA vs MQA vs GQA — shared K/V head groups, cache bytes per token, Llama and Mistral layouts, MHA-to-GQA uptraining, Harbor Support decode refactor, architecture decision table, pitfalls, and checklist.
• Multi-Head Latent Attention (MLA) explained: low-rank KV compression and long-context inference DeepSeek V2/V3 latent cache design — down/up projection, decoupled RoPE, MLA vs GQA cache arithmetic, Harbor Support 64k RAG refactor, architecture decision table, pitfalls, and checklist.
• Linear attention explained: subquadratic attention, kernel trick and long-sequence models O(n) attention via feature maps and associativity — Linear Transformer and Performer kernels, RetNet retention, causal recurrence without KV growth, Harbor Analytics CPU document triage refactor, architecture decision table, pitfalls, and checklist.
• Text embedding models explained: sentence vectors, bi-encoders and semantic search Dense vectors for query and document retrieval — bi-encoder pooling, contrastive InfoNCE training, E5 and BGE instruction prefixes, Matryoshka dimensions, Harbor Support RAG refactor, model decision table, pitfalls, and checklist.
• Mixture of experts (MoE) explained: sparse routing, expert parallelism and LLM scaling Sparse FFN activation with router top-k gating — load-balancing aux loss, capacity factors, expert parallel sharding, Mixtral and DeepSeek patterns, Harbor Support gateway refactor, architecture decision table, pitfalls, and checklist.
• Recurrent neural networks (RNN, LSTM, GRU) explained: sequence models and gating Hidden states across timesteps — vanilla RNN recurrence, vanishing gradients, LSTM forget/input/output gates, GRU update and reset gates, bidirectional stacks, BPTT training, RNN vs transformer decision table, and a production checklist.
• 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.
• State space models and Mamba explained: S4, selective SSMs and linear-time sequences Linear-time sequence modeling — continuous-time SSMs, HiPPO and S4, selective state spaces and parallel scan, Mamba vs transformers, Harbor Fleet telemetry forecaster worked example, architecture decision table, pitfalls, and checklist.
• 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.
• Text summarization explained: extractive, abstractive and LLM approaches Compress long documents into concise briefs — TextRank and sentence scoring, transformer seq2seq, LLM map-reduce, ROUGE and faithfulness metrics, long-document chunking, earnings news worked example, decision table, pitfalls, and checklist.
• Sentiment analysis explained: lexicons, classifiers, transformers and ABSA Classify opinion in reviews and social text — VADER lexicons, TF-IDF and transformer classifiers, aspect-based sentiment, LLM prompting vs fine-tuning, evaluation metrics, worked example, decision table, and checklist.
• Speech recognition explained: ASR pipelines, Whisper and word error rate Audio to text — mel spectrograms and acoustic models, CTC and RNN-T decoders, transformer ASR like Whisper, WER evaluation, streaming vs batch, Harbor Support call transcription worked example, approach decision table, pitfalls, and checklist.
• Text-to-speech explained: neural TTS, vocoders, voice cloning and MOS Text to audio — normalization and G2P, Tacotron and FastSpeech acoustic models, HiFi-GAN vocoders, prosody and SSML, zero-shot cloning ethics, MOS evaluation, Harbor Fleet navigation prompts worked example, approach decision table, pitfalls, and checklist.
• LLM voice agent pipeline explained: VAD, turn-taking, streaming STT/TTS and latency budgets Production voice AI — capture and VAD, end-of-turn detection, streaming ASR partials, parallel LLM and tool orchestration, clause-chunked TTS, barge-in and AEC, Harbor Clinic intake 4.2→1.8 s latency refactor, decision table vs chat bots, pitfalls, and checklist.
• Text classification explained: labels, features, models and production pipelines Assign categories to documents at scale — single vs multi-label taxonomies, rules and TF-IDF baselines, fine-tuned transformers and LLM zero-shot, class imbalance, Harbor support routing worked example, approach decision table, pitfalls, and checklist.
• 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.
• Natural language processing (NLP) fundamentals explained: text, tasks and modern pipelines Core NLP from preprocessing to production — tokenization, TF-IDF and embeddings, classification and NER and generation tasks, classical ML vs transformers vs LLMs, evaluation metrics, decision table, and a production checklist.
• 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.
• Generative adversarial networks (GAN) explained: generator, discriminator and training The classic two-network generative framework — minimax objectives, mode collapse and WGAN fixes, DCGAN and StyleGAN architectures, conditional GANs, FID evaluation, GAN vs diffusion trade-offs, and a production checklist.
• 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.
• Flow matching explained: rectified flow, ODE sampling and generative AI Velocity-field generative training — conditional flow matching, rectified flow and reflow distillation, Euler ODE solvers, SD3 patterns, Harbor Media asset pipeline refactor, technique decision table vs diffusion/GAN, pitfalls, and checklist.
• Consistency models explained: one-step generation, LCM and distillation Few-step generative inference — consistency function and property, consistency distillation vs training, latent consistency models (LCM/SDXL-Turbo), multi-step consistency sampling, Harbor Media thumbnail pipeline refactor, technique decision table vs diffusion/flow matching, pitfalls, and checklist.
• Score-based generative models explained: denoising score matching, Langevin dynamics and SDEs Learn the gradient of log-density at every noise scale — denoising score matching, annealed Langevin sampling, score SDE unification of diffusion and NCSN, Harbor Media latent QA refactor, technique decision table vs GAN/VAE/flow, pitfalls, and checklist.
• World models explained: learned simulators, video prediction and interactive environments Learned environment dynamics — latent RSSM and Dreamer patterns, JEPA representation prediction, diffusion and autoregressive video, action-conditioned rollouts, robotics sim-to-real, Harbor Robotics warehouse simulator worked example, architecture decision table, pitfalls, and checklist.
• 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

• Java fundamentals explained: JVM, OOP, collections and production backend patterns JVM bytecode and the JDK, classes and interfaces, generics and the Collections Framework, checked exceptions, Streams and records, Maven/Gradle builds, virtual threads, Harbor Payments ledger worked example, language decision table, pitfalls, and checklist.
• Kotlin fundamentals explained: null safety, coroutines and JVM backend patterns JVM and multiplatform targets, null-safe types, data classes and sealed hierarchies, coroutines and structured concurrency, extension functions, Gradle Kotlin DSL, Ktor HTTP services, Harbor Fleet mobile sync API worked example, language decision table, pitfalls, and checklist.
• Scala fundamentals explained: JVM, functional types and production backend patterns JVM bytecode and sbt, case classes and pattern matching, Options and Eithers, traits and for-comprehensions, Cats/ZIO and Pekko actors, Spark and Kafka interop, Harbor Analytics event pipeline worked example, language decision table, pitfalls, and checklist.
• Swift fundamentals explained: optionals, protocols, SwiftUI and server-side patterns Apple platform targets and Swift 6 concurrency, optionals and value semantics, protocol-oriented design, async/await and actors, SwiftUI versus UIKit, Swift Package Manager, Vapor HTTP services, Harbor Fleet iOS sync client worked example, language decision table, pitfalls, and checklist.
• C# fundamentals explained: .NET, types, LINQ and ASP.NET Core patterns CLR and the .NET SDK, value vs reference types, classes and records, nullable reference types, LINQ and async/await, NuGet and dotnet CLI, ASP.NET Core APIs, Harbor Supply inventory service worked example, language decision table, pitfalls, and checklist.
• Rust fundamentals explained: ownership, memory safety and systems programming Ownership and borrowing, lifetimes, Result and Option error handling, Cargo and crates, traits and generics, async Tokio concurrency, Arc and Mutex patterns, Solana on-chain programs, WASM targets, Harbor Chain indexer worked example, language decision table, pitfalls, and checklist.
• Tauri fundamentals explained: Rust core, web UI and lightweight desktop apps Cross-platform desktop apps with a Rust native core and system webview — invoke IPC commands, emit events, capabilities security, plugins, bundling and auto-update, Harbor Fleet offline cargo tracker worked example, framework decision table, pitfalls, and checklist.
• Electron fundamentals explained: main process, renderer IPC and desktop apps Cross-platform desktop apps with bundled Chromium and Node.js — main vs renderer processes, preload scripts and contextBridge, ipcMain handlers, electron-builder packaging, auto-update, Harbor Fleet ops dashboard worked example, framework decision table, pitfalls, and checklist.
• Express fundamentals explained: routing, middleware and production Node APIs Minimal Node.js HTTP framework — routing and Router modules, middleware chains, body parsing and error handlers, TypeScript and Zod validation, supertest testing, Harbor Payments webhook worked example, framework decision table, pitfalls, and checklist.
• Fastify fundamentals explained: schema validation, plugins and high-performance Node APIs Schema-first Node.js HTTP framework — JSON Schema routes, plugin encapsulation, hooks lifecycle, Pino logging, TypeScript inference, app.inject testing, Harbor Payments webhook API worked example, framework decision table, pitfalls, and checklist.
• Hono fundamentals explained: edge-first routing, Web Standards and multi-runtime APIs Ultralight web framework on Request/Response — routing and middleware on Cloudflare Workers, Deno, Bun and Node, JSX server rendering, Zod validation, Harbor Fleet edge status API worked example, framework decision table, pitfalls, and checklist.
• tRPC fundamentals explained: end-to-end type-safe APIs, routers and TanStack Query TypeScript RPC without OpenAPI codegen — routers and procedures, Zod input validation, context and middleware, SuperJSON serialization, TanStack Query client hooks, Harbor Commerce catalog API worked example, framework decision table, pitfalls, and checklist.
• NestJS fundamentals explained: modules, DI, guards and production APIs TypeScript Node.js framework — modules, controllers, providers, dependency injection, ValidationPipe and DTOs, guards and interceptors, ConfigModule, Prisma integration, Harbor Supply order service worked example, framework decision table, pitfalls, and checklist.
• Django fundamentals explained: MTV architecture, ORM, admin and production patterns Batteries-included Python web framework — project/app structure, models and migrations, QuerySet optimization, views and templates, forms and CSRF, built-in admin and auth, Django REST Framework, Harbor Supply inventory portal worked example, framework decision table, pitfalls, and checklist.
• Flask fundamentals explained: microframework, blueprints and production Python web apps WSGI microframework — application factory pattern, routing and blueprints, Jinja2 templates, Flask-SQLAlchemy and extensions ecosystem, pytest testing, Harbor Fleet status API worked example, framework decision table, pitfalls, and checklist.
• SQLAlchemy fundamentals explained: ORM, Core, sessions and Alembic migrations Python database toolkit — Engine and connection pooling, declarative models, SQLAlchemy 2.0 select API, relationships and eager loading, session transactions, Alembic migrations, Harbor Commerce inventory API worked example, ORM decision table, pitfalls, and checklist.
• PHP fundamentals explained: modern syntax, OOP, Composer and production web patterns Zend engine and PHP 8.x types, arrays and objects, namespaces and traits, Composer autoloading, PDO prepared statements, attributes and enums, queue workers, Harbor Media content API worked example, language decision table, pitfalls, and checklist.
• Ruby fundamentals explained: syntax, gems, Rails and production backend patterns MRI and the GVL, blocks and symbols, classes and modules, Bundler and gems, Rails and Sinatra, Active Record and Sidekiq jobs, Harbor Commerce webhook API worked example, language decision table, pitfalls, and checklist.
• Elixir fundamentals explained: BEAM, OTP, Phoenix and production backend patterns BEAM VM and Erlang heritage, pattern matching and pipes, processes and GenServer, supervision trees, Phoenix and LiveView, Ecto and Oban jobs, Harbor Fleet real-time status API worked example, language decision table, pitfalls, and checklist.
• Amazon S3 and object storage explained: buckets, keys, storage classes and IAM Object vs block vs file storage, S3 buckets and keys, Standard/IA/Glacier classes, IAM policies and pre-signed URLs, multipart upload, lifecycle and event notifications, Harbor Supply invoice archive worked example, storage decision table, pitfalls, and checklist.
• Linux fundamentals explained: kernel, shell, permissions and server operations Kernel vs userspace, filesystem hierarchy, processes and signals, users and chmod, apt packages, systemd services, SSH and firewalls, journalctl logs, Harbor VPS worked example, hosting decision table, pitfalls, and checklist.
• Bash shell scripting explained: variables, pipes, safety and automation Shebang and permissions, quoting and expansion, conditionals and loops, pipes and redirects, set -euo pipefail, functions and argument parsing, Harbor Fleet deploy worked example, Bash vs Python decision table, pitfalls, and checklist.
• SSH fundamentals explained: keys, config, tunnels and server hardening Ed25519 key pairs, ssh-agent and ~/.ssh/config, scp and rsync, ProxyJump bastions, local and remote port forwarding, sshd_config hardening, Harbor Fleet multi-server worked example, auth decision table, pitfalls, and checklist.
• nginx fundamentals explained: event-driven architecture, config blocks and production patterns Master/worker process model, http/server/location blocks, static files vs reverse proxy, upstream pools, TLS termination, gzip and edge caching, rate limiting, multi-service VPS worked example, server decision table, pitfalls, and checklist.
• Traefik fundamentals explained: dynamic routing, Docker labels and automatic HTTPS Static vs dynamic configuration, entrypoints/routers/services/middlewares, Docker and Kubernetes providers, ACME Let’s Encrypt TLS, load balancing and health checks, Harbor Fleet microservices worked example, reverse-proxy decision table, pitfalls, and checklist.
• Twelve-factor app explained: cloud-native design principles for scalable services Heroku’s SaaS methodology — codebase, dependencies, config in env vars, backing services, build-release-run, stateless processes, port binding, concurrency, disposability, dev/prod parity, logs as streams, admin one-offs, SaaS refactor worked example, decision table, pitfalls, and checklist.
• Raft consensus algorithm explained: leader election, log replication and fault tolerance Understandable distributed consensus — follower/candidate/leader roles, RequestVote and AppendEntries RPCs, commit index and quorum safety, split votes, joint consensus membership changes, etcd/Consul patterns, three-node worked example, protocol decision table, pitfalls, and checklist.
• Prisma fundamentals explained: schema, Client, migrations and production patterns Schema-first TypeScript ORM — Prisma schema language, type-safe Client queries, Migrate workflows, relations and transactions, connection pooling for serverless, Harbor Supply order API worked example, ORM decision table, pitfalls, and checklist.
• Zod fundamentals explained: runtime validation, type inference and API patterns Schema primitives and composition, parse vs safeParse, refinements and transforms, z.infer type inference, Hono and env validation integration, Harbor Payments fee API worked example, validation library decision table, pitfalls, and checklist.
• Drizzle fundamentals explained: TypeScript schema, SQL-like queries and drizzle-kit migrations Lightweight SQL-forward TypeScript ORM — table schemas and type inference, query builder and relational API, drizzle-kit generate/migrate/push, transactions and serverless pooling, drizzle-zod integration, Harbor Fleet shipment API worked example, ORM decision table, pitfalls, and checklist.
• PostgreSQL fundamentals explained: MVCC, indexes, WAL and production patterns Process architecture, MVCC and snapshots, B-tree and GIN indexes, write-ahead log, VACUUM and bloat, PgBouncer pooling, streaming replication, JSONB and partitioning, worked example, decision table, and a practitioner checklist.
• Supabase fundamentals explained: Postgres, auth, RLS, realtime and edge functions Managed PostgreSQL BaaS — project setup, JavaScript client, row-level security policies, auth flows and JWT claims, storage buckets, realtime subscriptions, edge functions, Harbor Commerce storefront worked example, BaaS decision table, pitfalls, and checklist.
• MySQL fundamentals explained: InnoDB, indexes, replication and production patterns InnoDB clustered indexes, buffer pool and redo log, MVCC and row locking, binlog replication with GTIDs, JSON and partitioning in MySQL 8, Harbor Retail inventory worked example, MySQL vs Postgres decision table, pitfalls, and checklist.
• SQLite fundamentals explained: embedded SQL, WAL mode, indexing and production patterns Serverless embedded architecture, page storage and single-writer locking, WAL vs rollback journal, dynamic typing and foreign keys, B-tree indexes and query planning, FTS5 and JSON1 extensions, local-first task tracker worked example, SQLite vs Postgres decision table, pitfalls, and checklist.
• DuckDB explained: embedded OLAP analytics, Parquet queries and local data warehousing Columnar vectorized execution, querying Parquet and CSV in place, Python and notebook integration, OLAP vs OLTP trade-offs, Harbor Supply order analytics worked example, database decision table, pitfalls, and checklist.
• ClickHouse explained: columnar OLAP, MergeTree engines and real-time analytics MergeTree storage and engine variants, ORDER BY and partitioning design, materialized views and TTL, replication and Kafka ingest, Harbor Fleet clickstream worked example, database decision table, pitfalls, and checklist.
• MongoDB fundamentals explained: documents, indexes, replica sets and schema design BSON document model, CRUD and aggregation pipelines, single and compound indexes, replica sets with read/write concern, sharding and shard keys, multi-document transactions, embedding vs referencing, e-commerce catalog worked example, decision table, pitfalls, and checklist.
• Redis fundamentals explained: data structures, caching, persistence and clustering In-memory data structures, TTL and eviction policies, cache-aside and stampede protection, RDB vs AOF persistence, replication and Sentinel failover, Redis Cluster hash slots, rate limiting and sessions, API gateway worked example, decision table, pitfalls, and checklist.
• Elasticsearch fundamentals explained: inverted indexes, Query DSL, sharding and relevance Lucene inverted indexes, mappings and analyzers, bool queries and BM25 scoring, aggregations and facets, shard and replica topology, bulk indexing and ingest pipelines, Harbor Market e-commerce worked example, decision table, pitfalls, and checklist.
• CAP theorem and consistency models explained: strong vs eventual consistency Distributed data trade-offs — partition tolerance, linearizability vs eventual consistency, PACELC, quorum reads, session guarantees, conflict resolution, and a decision table for backend engineers.
• CRDTs explained: conflict-free replicated data types for offline-first apps State-based vs operation-based CRDTs, G-Counter, OR-Set, LWW-Register, text sequence merges, Harbor Docs offline notes worked example, CRDT vs locking vs event sourcing decision table, pitfalls, and checklist.
• Optimistic vs pessimistic locking explained: version columns, row locks and concurrency control Prevent lost updates — SELECT FOR UPDATE row locks, version columns and compare-and-swap, ETags, MVCC interaction, deadlock ordering, retry strategies, distributed lock boundaries, and a strategy decision table.
• 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.
• Database migrations explained: versioned schema changes, zero-downtime deploys and rollback Versioned SQL scripts, forward-only vs reversible migrations, expand-contract zero-downtime patterns, DDL lock awareness, Flyway/Prisma/Alembic tooling, Harbor Supply order schema evolution worked example, approach decision table, pitfalls, and checklist.
• 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.
• SQL query optimization explained: EXPLAIN plans, SARGable predicates and slow query tuning Reading EXPLAIN output, SARGable WHERE clauses, join strategies, keyset pagination vs OFFSET, aggregation tuning, ORM pitfalls, and a production checklist beyond adding indexes.
• SQL window functions explained: ROW_NUMBER, LAG, running totals and analytic queries OVER clauses, PARTITION BY and ORDER BY, ranking and offset functions, frame boundaries, running and moving aggregates, Harbor Analytics subscription cohort worked example, window vs GROUP BY decision table, pitfalls, and checklist.
• Materialized views explained: precomputed SQL, refresh strategies and staleness trade-offs Stored query snapshots for fast reads — full vs concurrent refresh, incremental maintenance, indexing the snapshot, PostgreSQL vs MySQL patterns, decision table vs cache and replicas, and a production checklist.
• 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.
• Domain-driven design explained: bounded contexts, aggregates and ubiquitous language Strategic vs tactical DDD — bounded contexts and context maps, entities vs value objects, aggregate roots, domain events, anti-corruption layers, modular monoliths, and when lighter models beat full DDD.
• SOLID principles explained: SRP, OCP, LSP, ISP and DIP for maintainable code Five object-oriented design rules — single responsibility, open/closed, Liskov substitution, interface segregation, dependency inversion, Harbor Commerce checkout refactor worked example, pragmatism decision table, pitfalls, and checklist.
• Clean architecture explained: layers, the dependency rule and testable systems Concentric rings for business rules — entities and use cases at the center, interface adapters and frameworks on the outside, dependency inversion, hexagonal cousins, folder layouts, anti-patterns, and a production checklist.
• Hexagonal architecture explained: ports, adapters and testable application cores Alistair Cockburn ports and adapters — inbound vs outbound boundaries, primary and secondary drivers, application core isolation, Harbor Commerce guest checkout worked example, architecture decision table, pitfalls, and checklist.
• Monorepo architecture explained: tooling, boundaries and CI at scale Monorepo vs polyrepo trade-offs, Nx/Turborepo/Bazel orchestration, dependency graphs, affected builds, versioning strategies, CODEOWNERS, remote caching, migration paths, and a production checklist.
• Turborepo fundamentals explained: task pipelines, caching and monorepo builds turbo.json pipelines, task dependencies and outputs, local and remote caching, env-aware hashing, pnpm workspace filters, Harbor Commerce build graph worked example, orchestration decision table, pitfalls, and checklist.
• 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.
• Backend for Frontend (BFF) pattern explained: per-client APIs, aggregation and mobile shaping Client-specific orchestration layers — parallel fan-out aggregation, DTO shaping for mobile vs web, BFF vs API gateway vs GraphQL, session and auth at the edge, Harbor Commerce mobile checkout worked example, architecture decision table, pitfalls, and checklist.
• Strangler fig pattern explained: incremental legacy modernization without big-bang rewrites Facade routing and slice-by-slice replacement — expand-contract data moves, bounded-context migration order, Harbor Payments billing modernization worked example, modernization decision table, pitfalls, and checklist.
• Multi-tenancy architecture explained: SaaS isolation, security and noisy neighbors Shared schema vs database-per-tenant, tenant identification and JWT claims, row-level security, per-tenant rate limits, customization without code forks, compliance and offboarding, and a production checklist.
• Service mesh explained: Envoy sidecars, mTLS, Istio and traffic management East-west microservice fabric — data plane vs control plane, Envoy sidecars, mutual TLS and zero-trust, retries and canary routing, Istio vs Linkerd, observability, and when a mesh is worth the cost.
• 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.
• FastAPI fundamentals explained: async Python APIs, Pydantic and production patterns Path operations and Pydantic v2 validation, dependency injection, async SQLAlchemy, background tasks, OpenAPI docs, Harbor Payments order API worked example, framework decision table, pitfalls, and checklist.
• REST API design explained Resource naming, HTTP verbs, status codes, pagination, versioning, idempotency keys, and error shapes integrators expect.
• OpenAPI explained: API documentation, specs, code generation and contract testing Machine-readable REST contracts — YAML/JSON structure, reusable components and schemas, auth schemes, Swagger UI and Redoc, design-first vs code-first, SDK generation, Spectral linting, contract tests in CI, and a production checklist.
• 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.
• Infrastructure as code explained: Terraform, state, modules and CI/CD Declarative cloud provisioning — Terraform plan/apply workflow, remote state and locking, modules and stack boundaries, drift detection, environment promotion, policy checks, 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.
• Change data capture (CDC) explained: log-based streaming, Debezium and event pipelines Stream row-level inserts, updates, and deletes from Postgres WAL or MySQL binlog — CDC vs polling and triggers, Debezium connectors, search and cache sync, CDC vs outbox, ordering, schema evolution, and a production checklist.
• Data contracts explained: schema guarantees, producer-consumer agreements and breaking change detection Formal agreements between data producers and consumers — schema formats, backward and forward compatibility, registries and CI enforcement, Harbor orders topic worked example, decision table, pitfalls, and checklist.
• ETL and ELT data pipelines explained: batch, streaming, Airflow and warehouse design Move data from OLTP sources to analytics warehouses — ETL vs ELT, batch vs streaming, bronze/silver/gold layers, Airflow and dbt, incremental idempotent loads, schema evolution, data quality gates, and a production checklist.
• Data warehouses and lakehouses explained: OLAP, star schema, Snowflake and Delta Lake OLTP vs OLAP workloads, dimensional modeling with facts and dimensions, data lakes vs curated warehouses, Delta Lake and Iceberg lakehouses, partitioning and clustering, governance catalogs, and when each architecture fits.
• 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.
• dbt (Data Build Tool) explained: models, tests, lineage and analytics engineering SQL transformation layer for warehouses — staging and mart models, materializations and incremental loads, Jinja macros, tests and documentation, Harbor Supply revenue mart worked example, tooling decision table, pitfalls, and checklist.
• Apache Airflow explained: DAGs, schedulers, executors and workflow orchestration Batch workflow orchestration — DAG anatomy and task dependencies, operators and deferrable sensors, scheduling and backfill, Celery vs Kubernetes executors, Harbor Supply nightly ETL worked example, orchestrator decision table, pitfalls, and checklist.
• Celery fundamentals explained: distributed task queues, workers and Beat scheduling Python background jobs — Redis and RabbitMQ brokers, workers and concurrency, retries and late acks, Celery Beat cron, canvas chains and chords, Harbor Commerce order fulfillment worked example, task-queue decision table, pitfalls, and checklist.
• RabbitMQ explained: exchanges, queues, AMQP routing and reliable messaging Flexible AMQP task queues — direct, topic, fanout and headers exchanges, durable quorum queues, consumer acks and prefetch, publisher confirms, dead-letter exchanges, Harbor Fleet order notifications worked example, broker decision table, pitfalls, and checklist.
• Apache Kafka explained: topics, partitions, consumer groups and event streaming The distributed commit log behind modern event pipelines — partitions and keys, producer acks and idempotence, consumer groups and rebalancing, replication and ISR, retention vs compaction, delivery semantics, broker comparison, worked example, and checklist.
• Stream processing explained: windows, watermarks, Kafka Streams and Flink Process unbounded event feeds in real time — event time vs processing time, tumbling and session windows, watermarks, stateful joins, exactly-once semantics, engine comparison table, and a production checklist.
• Apache Flink explained: stateful stream processing, checkpoints and event time Record-by-record stream engine — JobManager and TaskManager architecture, DataStream and Flink SQL APIs, event-time windows and watermarks, RocksDB state and exactly-once checkpoints, Kafka connectors, Harbor Fleet fraud-scorer worked example, engine decision table, pitfalls, and checklist.
• Apache Spark explained: DataFrames, shuffle, Spark SQL and distributed ETL Distributed batch and micro-batch compute — driver-executor architecture, lazy Catalyst plans, partitions and shuffle tuning, broadcast joins and skew fixes, Structured Streaming, Harbor Supply nightly ETL worked example, engine decision table, pitfalls, and checklist.
• Exponential backoff and retry patterns explained: jitter, budgets and idempotency Prevent retry storms with exponential delay and jitter — retryable vs terminal errors, idempotency keys, Retry-After semantics, pairing with circuit breakers, DLQ exhaustion, and a production checklist.
• 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.
• Graceful degradation explained: fallbacks, load shedding and resilient UX Keep Tier 0 alive when optional dependencies fail — degradation tiers, stale-cache fallbacks, load shedding vs feature flags, critical-path timeouts, user messaging, circuit breaker pairing, and a production checklist.
• Graceful shutdown explained: SIGTERM, connection draining and zero-downtime deploys Stop intake, drain in-flight requests, and close pools before exit — signal handling, Kubernetes preStop hooks, load balancer deregistration delay, queue consumer semantics, and a production checklist.
• Health checks, liveness and readiness probes explained: Kubernetes and load balancers Liveness restarts stuck processes; readiness gates traffic — shallow vs deep checks, startup probes, kubelet timing, ALB alignment, restart-storm anti-patterns, probe decision table, and a production checklist.
• 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.
• Prometheus monitoring explained: metrics, PromQL, alerting and production patterns Pull-based scraping, counter/gauge/histogram types, labels and cardinality, PromQL rates and percentiles, recording rules, Alertmanager routing, exporters, Harbor Fleet worked example, tooling decision table, pitfalls, and checklist.
• Grafana explained: dashboards, data sources, alerting and production observability UI Visualization layer on Prometheus and Loki, RED and USE dashboard design, variables and templating, unified alerting vs Alertmanager, dashboard-as-code provisioning, Harbor Fleet SRE board worked example, tooling decision table, pitfalls, and checklist.
• Distributed tracing and OpenTelemetry explained: spans, context propagation and sampling Follow requests across microservices — traces and spans, W3C Trace Context headers, OTel SDKs and collectors, head vs tail sampling, Jaeger and Tempo backends, auto-instrumentation, worked example, and checklist.
• Structured logging explained: JSON logs, correlation IDs and production patterns Machine-parseable log records — JSON envelope fields, correlation and trace ID propagation, log level semantics, ELK and Loki aggregation, PII redaction, sampling, and a production checklist.
• SLOs and error budgets explained: SLIs, reliability targets and release policy Service level indicators vs objectives vs SLAs — nines math, error budget policies, multi-window burn-rate alerting, SLO implementation, and when to freeze risky releases.
• 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.
• Disaster recovery and backup strategies explained: RPO, RTO and multi-region failover Business continuity planning — RPO and RTO tiers, full vs incremental vs PITR backups, 3-2-1 rule, cold/warm/hot standby, active-active failover, DR game days, cloud patterns, and a production checklist.
• Load testing explained: k6, latency percentiles, stress tests and capacity planning Baseline vs stress vs soak vs spike tests — RPS and p95/p99 latency, realistic user journeys, k6 and Locust workflows, saturation curves, staging guardrails, and a production checklist before launch.
• A/B testing explained: hypothesis design, sample size and statistical significance Split-test with evidence — primary and guardrail metrics, MDE and power, p-values and confidence intervals, peeking traps, randomization and exposure logging, A/B vs canary vs feature flags, decision table, and a production checklist.
• 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.
• Backpressure explained: flow control, bounded queues and load shedding Propagate pressure upstream when producers outpace consumers — bounded queues, reactive streams, TCP and gRPC flow control, Kafka lag signals, shedding vs buffering, and a production checklist.
• 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.
• GitHub Actions fundamentals explained: workflows, jobs, secrets and CI/CD Built-in GitHub CI/CD — workflow YAML, jobs and steps, hosted runners, marketplace actions, secrets and environments, matrix builds, caching, reusable workflows, OIDC deploys, Harbor Supply pipeline worked example, tooling decision table, pitfalls, and checklist.
• 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.
• Git branching strategies explained: Git Flow, GitHub Flow and trunk-based development Choosing a team branching model — Git Flow release branches, GitHub Flow deployable main, trunk-based daily integration, release trains, environment branches, merge vs rebase policy, Harbor Commerce worked example, strategy decision table, pitfalls, and checklist.
• GitOps explained: pull-based deployments, Argo CD, Flux and production patterns Git as the source of truth for cluster state — declarative principles, reconciliation loops, Argo CD vs Flux, repo layout, Sealed Secrets and SOPS, drift detection, environment promotion, rollback, and a production checklist.
• Dependency injection explained: constructor injection, DI containers and testability Inversion of control and wiring collaborators from outside — constructor vs setter injection, NestJS and Spring containers, singleton vs scoped lifetimes, testing with mocks, service locator pitfalls, and a production checklist.
• 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.
• Playwright E2E testing explained: browser automation, locators and CI Real-browser end-to-end tests with Playwright — role-based locators, auto-waiting, fixtures and page objects, network mocking, trace debugging, Harbor Supply checkout worked example, tooling decision table, pitfalls, and checklist.
• Vitest fundamentals explained: fast unit tests, mocking and Vite integration Jest-compatible unit testing for Vite projects — vitest.config.ts, vi.mock and spies, Testing Library component tests, coverage and watch mode, workspace projects, Harbor Payments fee calculator worked example, tooling decision table, pitfalls, and checklist.
• pytest fundamentals explained: fixtures, parametrize and Python testing Python's de facto test runner — discovery and pyproject.toml, fixture scopes and conftest.py, parametrize tables, unittest.mock and pytest-mock, async and API integration, Harbor Commerce order validator worked example, tooling decision table, pitfalls, and checklist.
• Property-based testing explained: Hypothesis, generators and invariants Assert invariants over generated inputs instead of fixed examples — QuickCheck-style properties, Hypothesis and fast-check, shrinking minimal counterexamples, domain strategies, Harbor Commerce fee calculator worked example, approach decision table, pitfalls, and checklist.
• 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.
• Helm Kubernetes explained: charts, values, releases and production deployments Package manager for K8s — chart anatomy and Go templating, values.yaml layering, install/upgrade/rollback revisions, repositories and subcharts, Harbor Fleet umbrella chart worked example, Helm vs Kustomize decision table, pitfalls, and checklist.
• HashiCorp Vault explained: secrets management, dynamic credentials and production security Centralized secrets broker — seal/unseal and HA, KV v2, dynamic database and cloud credentials, PKI and Transit engines, AppRole and Kubernetes auth, HCL policies, Harbor Fleet order-service worked example, tooling decision table, pitfalls, and checklist.
• Autoscaling explained: horizontal scaling, HPA, metrics and production pitfalls Vertical vs horizontal scaling, reactive vs predictive policies, CPU/RPS/queue triggers, Kubernetes HPA and cluster autoscaler, scale-to-zero cold starts, hysteresis, cost caps, worked API example, and a production checklist.
• 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.
• Consistent hashing explained: hash rings, virtual nodes and distributed routing Route keys across a changing cluster with minimal remapping — modulo pitfalls, the hash ring, vnodes, rendezvous and jump hashing, cache and shard use cases, hotspot mitigation, 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

• React Server Components explained: server vs client, data fetching and the RSC model Move data fetching off the client — server vs client boundaries, async components, serialization rules, composition patterns, Next.js App Router integration, Harbor Commerce catalog refactor worked example, decision table, pitfalls, and checklist.
• React error boundaries explained: graceful failures, fallback UI and production recovery Isolate render-time crashes — what boundaries catch and miss, class vs react-error-boundary library, granular vs route placement, reset keys and logging, Next.js error.tsx, Harbor Commerce checkout worked example, decision table, pitfalls, and checklist.
• Code splitting explained: dynamic imports, route chunks and faster web apps Shrink initial JavaScript bundles — dynamic import(), route and component lazy loading, vendor chunk strategy, preload hints, React.lazy and Next.js patterns, Harbor Commerce dashboard refactor worked example, strategy decision table, pitfalls, and checklist.
• Tree shaking explained: dead code elimination, ES modules and smaller bundles Remove unused JavaScript at build time — static ES module analysis, sideEffects flags, barrel-file pitfalls, lodash and icon-library patterns, Webpack/Rollup/Vite/esbuild behavior, Harbor Commerce icon refactor worked example, technique decision table, pitfalls, and checklist.
• Resource hints explained: preload, prefetch, preconnect and Priority Hints Start critical fetches early — dns-prefetch, preconnect, prefetch, preload, modulepreload, fetchpriority, crossorigin rules, Harbor Commerce storefront LCP refactor worked example, hint decision table, pitfalls, and checklist.
• Intersection Observer API explained: lazy loading, infinite scroll and viewability Detect viewport entry without scroll polling — root, rootMargin, threshold, lazy image loading, infinite scroll sentinels, ad viewability, scroll animations, Harbor Commerce catalog refactor worked example, technique decision table, pitfalls, and checklist.
• Resize Observer API explained: element size changes, charts and responsive components Detect container dimension changes without window listeners — observe and disconnect, contentBoxSize vs borderBoxSize, chart reflow, text truncation, sidebar collapse, Harbor Commerce analytics dashboard refactor worked example, technique decision table, pitfalls, and checklist.
• CSS container queries explained: component-responsive layout without viewport breakpoints Style components by parent width — container-type, @container rules, cqw and cqi units, size vs inline-size, card and sidebar patterns, Harbor Commerce dashboard refactor worked example, technique decision table, pitfalls, and checklist.
• View Transitions API explained: SPA morphs, cross-document navigation and shared elements Animate DOM and page navigations — startViewTransition, view-transition-name, same-document vs cross-document opt-in, ::view-transition pseudo-elements, Harbor Commerce catalog refactor worked example, technique decision table, pitfalls, and checklist.
• CSS content-visibility explained: skip off-screen rendering, contain-intrinsic-size and faster pages Defer layout and paint for below-the-fold sections — content-visibility auto vs hidden, contain-intrinsic-size placeholders, pairing with Intersection Observer, Harbor Commerce long-form refactor worked example, technique decision table, pitfalls, and checklist.
• CSS :has() selector explained: parent-conditional styling without JavaScript Relational pseudo-class for parent styling from child state — form validation groups, card variants, empty states, sibling-aware rules, performance and browser support, Harbor Commerce checkout refactor worked example, technique decision table, pitfalls, and checklist.
• CSS subgrid explained: nested grid alignment, row and column track inheritance Share parent grid tracks across nested rows — column and row subgrid, spanning and named lines, comparison tables and form grids, Harbor Commerce product table refactor worked example, technique decision table, @supports fallbacks, pitfalls, and checklist.
• CSS anchor positioning explained: anchor(), position-anchor and tooltips without JavaScript Tie popovers to elements declaratively — anchor-name, position-anchor, position-area, anchor() inset functions, position-try-fallbacks flip behavior, Harbor Commerce product tooltip refactor worked example, technique decision table, @supports fallbacks, pitfalls, and checklist.
• CSS scroll-driven animations explained: scroll-timeline, view-timeline and scroll-linked motion Tie keyframes to scroll progress — scroll() and view() timelines, animation-range entry/cover/exit windows, reading progress bars and section reveals, Harbor Commerce long-form article refactor worked example, technique decision table vs Intersection Observer and ScrollTrigger, pitfalls, and checklist.
• CSS cascade layers explained: @layer order, specificity and stylesheet architecture Control who wins CSS conflicts before specificity — @layer declaration stacks, unlayered precedence, @import layer() for vendor sandboxes, design-system reset/tokens/components/utilities, Harbor Commerce checkout refactor worked example, technique decision table vs BEM and CSS Modules, pitfalls, and checklist.
• CSS nesting explained: & selectors, specificity and component stylesheets Native nesting without Sass — implicit and explicit nesting, & parent selector patterns, specificity and @layer pairing, :has() colocation, Sass migration traps, Harbor Commerce product card refactor worked example, technique decision table vs BEM and CSS Modules, pitfalls, and checklist.
• WebGPU fundamentals explained: adapters, WGSL shaders and browser GPU compute Modern browser GPU access — adapter and device lifecycle, WGSL compute and render pipelines, bind groups and command encoders, Harbor Commerce analytics heatmap refactor, technique decision table vs WebGL and WASM, pitfalls, and checklist.
• Web Streams API explained: ReadableStream, backpressure, piping and large downloads Chunked browser I/O — ReadableStream, WritableStream, TransformStream, fetch body streaming, TextDecoderStream and CompressionStream, backpressure and AbortSignal cancellation, Harbor Commerce CSV export refactor, technique decision table vs SSE and buffering, pitfalls, and checklist.
• Scheduler Yield API explained: scheduler.yield(), cooperative chunking and INP responsiveness Break up long main-thread loops without Web Workers — scheduler.yield() promise semantics, time-budget chunking, setTimeout and postTask comparison, Harbor Commerce catalog sort refactor, technique decision table, pitfalls, and checklist.
• Long Animation Frames API explained: LoAF script attribution, INP debugging and main-thread blame Per-script blocking duration on slow frames — long-animation-frame entries, invoker types and source URLs, correlating LoAF with INP event entries, Harbor Commerce checkout refactor, technique decision table vs longtask and DevTools, pitfalls, and checklist.
• Performance Observer API explained: LCP, INP, long tasks and RUM instrumentation Subscribe to the performance timeline — buffered observers, largest-contentful-paint, layout-shift and event entry types, longtask attribution, Harbor Commerce checkout RUM refactor, technique decision table vs web-vitals and CrUX, pitfalls, and checklist.
• Speculation Rules API explained: prerender, prefetch and instant navigation Declarative document speculation — prefetch vs prerender modes, eagerness and matcher syntax, analytics prerendering guardrails, Harbor Commerce checkout navigation refactor, technique decision table vs resource hints and framework prefetch, pitfalls, and checklist.
• Navigation API explained: navigate events, history entries and SPA routing Unified navigation control — NavigationHistoryEntry key/state, navigate event intercept, traverseTo and reload, scroll and focus restoration, Harbor Commerce catalog refactor, technique decision table vs History API and framework routers, pitfalls, and checklist.
• Broadcast Channel API explained: cross-tab messaging without a server Same-origin tab sync — channel naming, structured-clone payloads, cart and logout fan-out, Harbor Commerce multi-tab refactor, technique decision table vs storage events and SharedWorker, pitfalls, and checklist.
• CSS @scope explained: scoped styles, proximity limits and component boundaries Cascade-level encapsulation without Shadow DOM — scope roots, to() proximity limits, :scope pseudo-class, @layer pairing, Harbor Commerce dashboard refactor worked example, technique decision table vs BEM and CSS Modules, pitfalls, and checklist.
• HTML Popover API explained: popover attribute, light dismiss and accessible overlays Native transient overlays — popover auto vs manual, top layer stacking, showPopover and togglePopover, pairing with CSS anchor positioning, Harbor Commerce filter menu refactor, technique decision table vs dialog and custom portals, pitfalls, and checklist.
• 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.
• HTML fundamentals explained: document structure, semantic elements and accessible markup The web's structural layer — DOCTYPE and document skeleton, semantic HTML5 landmarks, links and media, forms and labels, head metadata for SEO, Harbor product page worked example, element decision table, pitfalls, and checklist.
• CSS fundamentals explained: selectors, box model, cascade and custom properties The web's presentation layer — selectors and specificity, cascade and inheritance, box model and box-sizing, display modes, units and colors, custom properties, Harbor product card worked example, property decision table, pitfalls, and checklist.
• Tailwind CSS fundamentals explained: utility-first styling, v4 @theme and production patterns Utility-first CSS philosophy, spacing and typography scales, responsive and state variants, Tailwind v4 @theme tokens and @source scanning, @apply vs composition, framework integration, Harbor Supply dashboard worked example, tooling decision table, pitfalls, and checklist.
• Vite fundamentals explained: dev server, HMR and production builds Native ESM dev server, esbuild dependency pre-bundling, Rollup production output, vite.config.ts and plugins, VITE_ env variables, React/Vue/Svelte integration, Harbor Archive editorial dashboard worked example, tooling decision table, pitfalls, and checklist.
• Storybook fundamentals explained: component stories, controls and design systems UI component workshop — CSF stories, args and controls, decorators and providers, interaction tests with play functions, autodocs, essential addons, Chromatic visual regression, Harbor Commerce design system worked example, tooling decision table, pitfalls, and checklist.
• esbuild fundamentals explained: fast bundling, transpilation and build pipelines Go-powered JavaScript/TypeScript bundler — transform vs build APIs, plugins and loaders, watch mode with context(), TypeScript/JSX compilation, externals and tree shaking, Harbor Commerce widget pipeline worked example, bundler decision table, pitfalls, and checklist.
• Webpack fundamentals explained: entry points, loaders, plugins and production builds Static module bundler for enterprise frontends — entry/output config, loaders and plugins, dev server HMR, code splitting and tree shaking, Module Federation, Harbor Commerce legacy migration worked example, bundler decision table, pitfalls, and checklist.
• ESLint fundamentals explained: flat config, rules and TypeScript linting Pluggable JavaScript/TypeScript linter — flat config arrays, rule severity and autofix, plugins and shareable presets, typescript-eslint type-aware rules, IDE and CI integration, Harbor Commerce monorepo worked example, tooling decision table, pitfalls, and checklist.
• Prettier fundamentals explained: config, format on save and ESLint integration Opinionated code formatter — configuration options, ignore files, editor format-on-save, eslint-config-prettier pairing, CI and pre-commit hooks, monorepo patterns, Harbor Commerce worked example, tooling decision table, pitfalls, and checklist.
• Astro fundamentals explained: islands architecture, content collections and static sites HTML-first content framework, .astro components, islands hydration with client directives, content collections and MDX, React/Vue/Svelte integrations, static vs SSR output, Harbor Archive docs portal worked example, framework decision table, pitfalls, and checklist.
• Qwik fundamentals explained: resumability, signals and instant-loading web apps Resumability vs hydration, $ signals and fine-grained reactivity, Qwik City routing and route loaders, server$ RPC, optimizer lazy boundaries, static and edge deployment, Harbor Commerce catalog worked example, framework decision table, pitfalls, and checklist.
• Tauri fundamentals explained: Rust core, web UI and lightweight desktop apps Cross-platform desktop apps with a Rust native core and system webview — invoke IPC commands, emit events, capabilities security, plugins, bundling and auto-update, Harbor Fleet offline cargo tracker worked example, framework decision table, pitfalls, and checklist.
• Electron fundamentals explained: main process, renderer IPC and desktop apps Cross-platform desktop apps with bundled Chromium and Node.js — main vs renderer processes, preload scripts and contextBridge, ipcMain handlers, electron-builder packaging, auto-update, Harbor Fleet ops dashboard worked example, framework decision table, pitfalls, and checklist.
• HTMX fundamentals explained: hypermedia-driven apps, hx-* attributes and server HTML Partial page updates without a SPA bundle — hx-get and hx-post, targets and swaps, hx-boost navigation, out-of-band updates, HX-Request server patterns, Harbor Supply order dashboard worked example, approach decision table, pitfalls, and checklist.
• 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.
• CDN explained: edge caching, anycast routing and global web performance Content delivery networks — edge PoPs, cache hierarchies and origin shields, DNS and anycast routing, TLS termination, purge strategies, static vs dynamic content, DDoS and WAF, provider trade-offs, and a production checklist.
• HTTP fundamentals explained: requests, responses, methods and status codes Request-response anatomy, HTTP methods and idempotency, status code families, essential headers, content negotiation, cookies, Harbor API traced example, method decision table, pitfalls, and checklist.
• 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.
• Optimistic UI updates explained: instant feedback, rollback and conflict handling Update local state before the server responds — snapshot/apply/request/reconcile lifecycle, TanStack Query mutations, idempotency keys, Harbor Commerce cart worked example, pessimistic vs optimistic decision table, pitfalls, and checklist.
• 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.
• Deno fundamentals explained: secure runtime, permissions and TypeScript-first JavaScript Ryan Dahl's secure-by-default JavaScript runtime — V8 and Rust, explicit permission flags, ESM and JSR imports, npm compatibility, Deno.serve and testing, Harbor Fleet webhook relay worked example, runtime decision table, pitfalls, and checklist.
• Bun fundamentals explained: fast runtime, package manager and all-in-one JavaScript toolkit JavaScriptCore and Zig runtime — bun install, native TypeScript and JSX, Bun.serve, bun:sqlite, Jest-compatible bun test, Node.js compatibility, Harbor Supply order API worked example, runtime decision table, pitfalls, and checklist.
• pnpm fundamentals explained: content-addressable store, workspaces and monorepos Performant npm — global store and hard links, strict node_modules layout, pnpm-lock.yaml, workspace protocol, .npmrc and frozen CI installs, Harbor Commerce monorepo worked example, package manager decision table, pitfalls, and 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.
• Virtual scrolling explained: windowing, overscan and large list performance Render million-row lists without freezing the browser — viewport windowing, fixed vs variable row heights, overscan buffers, TanStack Virtual patterns, Harbor Analytics ledger worked example, decision table, pitfalls, and checklist.
• React Suspense and concurrent rendering explained: boundaries, transitions and streaming Stay responsive while data loads — Suspense boundaries and fallbacks, useTransition and useDeferredValue, streaming SSR with Next.js, Harbor Commerce product page worked example, decision table, pitfalls, and checklist.
• 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.
• TypeScript generics and advanced types explained: constraints, mapped types and utility types Generic functions and constraints, keyof and indexed access, conditional and mapped types, built-in utilities, template literal types, Harbor Commerce fee API refactor worked example, pattern decision table, pitfalls, and checklist.
• 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.
• Vue.js fundamentals explained: reactivity, Composition API and single-file components Fine-grained reactivity with ref and computed, template directives, props and emits, script setup SFCs, composables, Pinia and Vite tooling, Harbor Fleet dispatch dashboard worked example, framework decision table, pitfalls, and checklist.
• Angular fundamentals explained: components, dependency injection and signals TypeScript-first enterprise framework — standalone components, templates and data binding, DI and services, signals with RxJS, reactive forms, Angular Router and HttpClient, Harbor Procurement purchase-order portal worked example, framework decision table, pitfalls, and checklist.
• RxJS fundamentals explained: Observables, operators and reactive streams Lazy cancellable streams for async events — creation operators, pipe and map/filter/debounce, switchMap vs mergeMap, Subjects and shareReplay, error handling and teardown, Harbor Fleet live tracker worked example, reactive tooling decision table, pitfalls, and checklist.
• Svelte fundamentals explained: compile-time reactivity, stores and SvelteKit Compiler-driven UI without a virtual DOM runtime — reactive assignments and $: labels, props and events, bind directives, writable and derived stores, SvelteKit load functions and adapters, Harbor Archive editorial dashboard worked example, framework decision table, pitfalls, and checklist.
• SolidJS fundamentals explained: signals, fine-grained reactivity and no virtual DOM Signals and memos, components that run once, Show/For control flow, stores and resources, Solid Router and SolidStart SSR, Harbor Fleet dispatch dashboard worked example, framework decision table, pitfalls, and checklist.
• SvelteKit fundamentals explained: file routing, load functions and form actions Full-stack Svelte meta-framework — +page and +layout conventions, server and universal load functions, progressive-enhancement form actions, hooks and adapters, prerender vs SSR, Harbor Archive publishing portal worked example, framework decision table, pitfalls, and checklist.
• Next.js fundamentals explained: App Router, Server Components and full-stack React File-based App Router conventions, React Server Components vs client components, fetch caching and ISR, route handlers and middleware, Harbor Supply catalog worked example, framework decision table, pitfalls, and checklist.
• Remix fundamentals explained: loaders, actions and full-stack React File-based routes, loaders and actions on Web Standard Request/Response, nested layouts and outlets, progressive enhancement, Vite build pipeline, Harbor Supply order portal worked example, framework decision table, pitfalls, and checklist.
• Nuxt fundamentals explained: Vue full-stack, Nitro server and file-based routing File-based pages and layouts, auto-imports, useFetch and useAsyncData, Nitro server API routes, SSR/SSG/SPA route rules, modules ecosystem, Harbor Fleet cargo tracker worked example, framework decision table, pitfalls, and checklist.
• 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.
• TanStack Query fundamentals explained: server state, caching and mutations QueryClient setup, useQuery and useMutation, stale time and hierarchical invalidation, optimistic updates, infinite queries, SSR hydration, Harbor Commerce catalog worked example, library decision table, pitfalls, and checklist.
• 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.
• Internationalization (i18n) explained: locales, translation, RTL and global web apps i18n vs l10n, BCP 47 locales, ICU MessageFormat plurals, Intl date/number/currency formatting, RTL layouts, server vs client i18n, hreflang SEO, Harbor Commerce storefront refactor worked example, decision table, pitfalls, and checklist.

Game development

• Unity fundamentals explained: GameObjects, C# scripting and production workflow Component model and scene hierarchy, C# MonoBehaviour lifecycle, prefabs and ScriptableObjects, Input System, 2D/3D physics and UI, URP packages and builds, Harbor Arcade coin collector worked example, engine decision table, pitfalls, and checklist.
• Godot fundamentals explained: scenes, GDScript and 2D/3D game development Scene tree and nodes, typed GDScript and signals, CharacterBody2D physics, collision layers, Control UI, export presets, Harbor Arcade duck collector worked example, engine decision table, pitfalls, and checklist.
• Phaser fundamentals explained: scenes, Arcade physics and browser 2D games Phaser 3 scene lifecycle, preload and asset pipelines, Arcade and Matter physics, sprites and tilemaps, input and cameras, Harbor Arcade token runner worked example, framework decision table, pitfalls, and checklist.
• Puzzle platformer game design explained: precision movement, room logic and fair failure Precision gauntlet, manipulation and chamber logic subgenres, coyote time and dash tuning, teach-test-twist room layout, checkpoint and assist philosophy, Harbor Ascent wind shrine worked example, subgenre decision table, pitfalls, and checklist.
• Game pressure plate and switch puzzle systems explained: logic gates, weight rules and door coupling Emitter-logic-receiver signal graphs — momentary vs toggle plates, AND/OR/XOR combinators, timed decay and latches, physics weight thresholds, color-matched feedback, Harbor Vault 22→71% refactor, technique decision table, pitfalls, and checklist.
• Game light beam and mirror reflection puzzle systems explained: ray routing, color filters and receiver logic Authoritative ray march for VFX and gameplay — fixed vs rotating mirrors, beam splitters, color mixers, receiver AND chains, Harbor Prism Sanctum 19→74% refactor, technique decision table vs pressure plates, pitfalls, and checklist.
• Game door, key and lock puzzle systems explained: inventory keys, multi-door graphs and permission gates Reachability graphs for spatial gating — colored and tiered keys, lock FSMs, consumable vs persistent tokens, softlock CI, Harbor Vault 22→71% optional-route refactor, technique decision table vs pressure plates, pitfalls, and checklist.
• Game block-pushing and Sokoban puzzle systems explained: grid physics, deadlocks and undo Warehouse push puzzles — grid occupancy, canonical push rules, ice slides, corner deadlocks, reverse BFS validation, Harbor Quarry 18→69% refactor, technique decision table vs pressure plates, pitfalls, and checklist.
• Game portal pair teleport puzzle systems explained: momentum, surfaces and chamber design Portal-gun spatial puzzles — paired entry/exit endpoints, velocity through rotated frames, surface tagging, cube routing and momentum flings, Harbor Prism Lab 24→71% refactor, technique decision table vs fast travel, pitfalls, and checklist.
• Game circuit and power routing puzzle systems explained: wires, logic gates and signal graphs Power-bus topology puzzles — wire graphs, AND/OR/XOR gates, splitters and diodes, sustained vs pulse semantics, junction merge rules, softlock validation, Harbor Generator Station 21→68% refactor, technique decision table vs pressure plates and beams, pitfalls, and checklist.
• Game weight balance scale puzzle systems explained: thresholds, totals and combination logic Numeric gating puzzles — single-pan thresholds, dual-pan equality, weight property models, player inclusion policy, physics settle windows, Harbor Vault Scale Sanctum 19→64% refactor, technique decision table vs pressure plates and Sokoban, pitfalls, and checklist.
• Physics puzzle game design explained: trajectories, simulation and satisfying collapse Slingshot, rope-cut, fluid routing and stacking subgenres, aim-simulate-observe loops, deterministic tuning and material tables, star ratings and shot limits, Harbor Tumble crane puzzle worked example, subgenre decision table, pitfalls, and checklist.
• Cooking and restaurant sim game design explained: orders, kitchen flow and service pressure Time-management kitchen, spatial co-op chaos, restaurant tycoon and narrative cooking subgenres, order-to-serve loops, recipe step graphs, patience meters, layout routing, Harbor Bistro worked example, subgenre decision table, pitfalls, and checklist.
• Detective and mystery game design explained: clues, deduction and fair accusations Courtroom drama, deduction board, open-world investigation and cozy whodunit subgenres, observe-collect-connect-accuse loops, clue journals and contradiction systems, alibi matrices, Harbor Investigation worked example, subgenre decision table, pitfalls, and checklist.
• Escape room game design explained: puzzle chains, locks and co-op flow Single-room simulators, chapter campaigns, asymmetric co-op and mobile tap subgenres, observe-solve-unlock loops, lock hierarchies and puzzle DAGs, inventory and hint economies, Harbor Vault worked example, subgenre decision table, pitfalls, and checklist.
• Game modding design explained: SDKs, Workshop pipelines and community safety Cosmetic vs gameplay vs total-conversion mod tiers, data-driven schemas and scripting APIs, Steam Workshop and curated hubs, load order and versioning, moderation and competitive integrity, Harbor Forge worked example, strategy decision table, pitfalls, and checklist.
• Minigame design explained: embedded loops, pacing and reward integration Reflex, puzzle, rhythm, luck and social micro-loops, enter-play-reward-exit structure, duration and difficulty tuning, narrative justification, parent-game economy alignment, accessibility and party modes, Harbor Carnival festival worked example, subgenre decision table, pitfalls, and checklist.
• Trivia and quiz game design explained: questions, scoring and social play Couch party, buzzer, live scheduled, async daily and educational subgenres, question authoring and difficulty calibration, speed bonuses and wager rounds, anti-cheat and content pipelines, Harbor Quiz Night worked example, subgenre decision table, pitfalls, and checklist.
• Time loop game design explained: knowledge persistence, schedules and narrative payoff Exploration mystery, action roguelite, schedule sim and meta-loop subgenres, reset triggers and persistence tiers, timetable and causal-chain puzzles, loop compression, Harbor Observatory worked example, subgenre decision table, pitfalls, and checklist.
• Roguelike game design explained: permadeath, procedural dungeons and the Berlin Interpretation Traditional turn-based, real-time roguelite, tactical squad and narrative hybrid subgenres, explore-fight-manage-die-learn loops, turn order and FOV, item identification and hunger clocks, Harbor Depths worked example, subgenre decision table, pitfalls, and checklist.
• Roguelike deckbuilder game design explained: map routes, relics and run pacing Map spire, lane defense, narrative act and poker hybrid subgenres, route-fight-reward-adapt loops, branching map node design, card and relic reward pacing, deck thinning, elite and boss encounters, ascension ladders, Harbor Voyage worked example, subgenre decision table, pitfalls, and checklist.
• Stealth game design explained: infiltration loops, route planning and ghost scoring Infiltration sandbox, cinematic, horror hide, squad breach and immersive sim subgenres, observe-plan-execute-exfiltrate loops, multi-route level design, ghost vs lethal scoring, alert recovery, social disguise layers, Harbor Dockyard worked example, subgenre decision table, pitfalls, and checklist.
• Survival crafting game design explained: gathering, tech trees and base progression Sandbox, session saga, hardcore PvP and cozy subgenres, gather-craft-build-survive loops, material tiers and biome gating, base building as progression, threat escalation curves, multiplayer persistence, Harbor Outpost worked example, subgenre decision table, pitfalls, and checklist.
• Horde survivor game design explained: auto-attacks, build synergies and timed runs Bullet heaven and Vampire Survivors-style subgenres, move-collect-level escalate loops, auto-weapons and evolution recipes, XP magnetism and pick-screen UX, spawn directors and performance caps, Harbor Swarm worked example, subgenre decision table, pitfalls, and checklist.
• Action-adventure game design explained: exploration, combat and environmental puzzles Cinematic third-person vs Zelda-like subgenres, explore-fight-puzzle loops, gadget progression and soft gates, boss arenas as spatial puzzles, environmental storytelling, Harbor Ruins worked example, subgenre decision table, pitfalls, and checklist.
• Flight simulator game design explained: arcade, study sim, combat and IFR systems Arcade vs study sim vs combat subgenres, preflight-plan-fly-land loops, flight model fidelity and assists, avionics and IFR navigation, weather and ATC, Harbor Airways worked example, subgenre decision table, pitfalls, and checklist.
• Space simulator game design explained: Newtonian flight, trade routes and galactic scale Arcade dogfight vs trading vs engineering vs 4X subgenres, navigate-scan-engage-expand loops, flight assist and jump fuel, sensors and combat, ship loadouts, procedural galaxies, Harbor Orbit trade corridor worked example, subgenre decision table, pitfalls, and checklist.
• Vehicular combat game design explained: handling, loadouts and arena flow Arcade car brawl vs armored sim vs convoy subgenres, spot-maneuver-fire-evade loops, handling and hardpoints, arena cover and sightlines, team modes and AI, Harbor Convoy worked example, subgenre decision table, pitfalls, and checklist.
• Submarine and naval warfare game design explained: sonar, stealth and fleet tactics Sub sim vs surface fleet vs arcade naval subgenres, contact-classify-approach-engage-withdraw loops, passive and active sonar, depth and thermoclines, torpedo fire control, fleet missions, Harbor Depths patrol worked example, subgenre decision table, pitfalls, and checklist.
• Factory automation game design explained: belts, production chains and logistics 2D belt sim vs 3D exploration builder subgenres, extract-process-assemble loops, throughput and bottlenecks, power and pollution constraints, research pacing, combat vs peaceful modes, Harbor Works copper expansion worked example, subgenre decision table, pitfalls, and checklist.
• Transport sim game design explained: routes, timetables, multi-modal networks and demand Rail, road, water, and air subgenres, plan-build-schedule-expand loop, passenger vs cargo demand, station catchment and transfer penalties, signals and congestion, Harbor Transit lakeshore corridor worked example, subgenre decision table, pitfalls, and checklist.
• MMORPG game design explained: worlds, progression, social systems and endgame Theme-park vs sandbox subgenres, tab-target vs action combat, explore-quest-progress-socialize loops, zones and instances, leveling and gear catch-up, guilds and LFG tools, raid tuning and seasonal content, Harbor Archipelago worked example, subgenre decision table, pitfalls, and checklist.
• Creature collection game design explained: capture, type charts and team building Classic turn-based vs action-capture subgenres, explore-encounter-capture-train loops, type charts and evolution lines, catch rate tuning, team synergy and Pokedex completion, breeding and fusion, Harbor Isles archipelago worked example, subgenre decision table, pitfalls, and checklist.
• Point-and-click adventure game design explained: hotspots, inventory and story puzzles Classic comedy vs serious narrative vs escape-room subgenres, observe-interact-inventory-solve loops, hotspot readability and cursor design, dialog trees and knowledge flags, fair inventory puzzle cluing, tiered hint systems, Harbor Museum heist worked example, subgenre decision table, pitfalls, and checklist.
• Tactical shooter game design explained: planning, lethality and squad coordination Competitive round-based vs SWAT sim vs top-down squad subgenres, observe-plan-execute-debrief loops, lethal TTK and gunplay roles, cover and suppression, breaching gadget economy, squad AI commands, intel fog-of-war, Harbor Security warehouse breach worked example, subgenre decision table, pitfalls, and checklist.
• Game buy phase and economy round systems explained: loss bonus, eco rounds and anti-snowball design Tactical shooter macro economy — buy phase FSM, win/loss/kill income bands, eco vs force vs full buy tiers, weapon pricing curves, loss-bonus caps, Harbor Strike 68→41% stomp-rate refactor, decision table vs flat loadouts, pitfalls, and checklist.
• Game buy zone and spawn area restriction systems explained: purchase geofencing, freeze gates and fair round starts Spawn buy volumes and movement gates — server purchase validation, personal exit commit, asymmetric freeze policy, Harbor Vanguard 54→9% unfair-start refactor, decision table vs timer-only buy, pitfalls, and checklist.
• Game round timer, freeze time and match phase systems explained: competitive clocks, buy overlap and server authority Tactical shooter timing FSM — freeze time, buy-phase overlap, round clock vs bomb timer, round-end delay, server-authoritative phase transitions, Harbor Ridge 54→11% timing-dispute refactor, decision table vs endless rounds, pitfalls, and checklist.
• Game tactical timeout and match pause systems explained: budget rules, freeze state and competitive fairness Competitive pause design — per-half timeout budgets, server pause FSM, bomb-timer tick policy on plant, buy-menu locks, overtime extensions, Harbor Summit 52→9% stall-abuse refactor, decision table vs unlimited pauses, pitfalls, and checklist.
• Game armor and helmet damage reduction systems explained: body shields, headshot rules and economy Tactical shooter survivability — light vs heavy body tiers, helmet headshot rules, flat vs percentage mitigation, durability carryover, buy-menu effective HP, Harbor Vanguard 44→11% TTK confusion refactor, decision table vs HP-only, pitfalls, and checklist.
• Game weapon damage falloff and range attenuation systems explained: distance curves, TTK bands and readability Tactical shooter damage at distance — falloff curve taxonomy, distance measurement, pipeline order with armor and penetration, shotgun pellets, Harbor Crest 51→13% range confusion refactor, decision table vs flat damage, pitfalls, and checklist.
• Game loadout customization systems explained: preset slots, attachment rules and pre-match setup Shooter kit design — slot schemas, preset FSM, attachment point budgets, class gates, pre-round vs mid-match edits, share codes, Harbor Arsenal 54→16% wrong-kit death refactor, decision table vs buy-phase trees, pitfalls, and checklist.
• Game bomb plant and defuse objective systems explained: site timers, carrier rules and round tension Search-and-destroy objective design — round and device FSMs, site plant volumes, carrier drop and stall prevention, plant/defuse channels, audio telegraphs, economy coupling, Harbor Strike 54→22% stall-round refactor, decision table vs TDM modes, pitfalls, and checklist.
• Game bomb carrier and objective holder indicator systems explained: HUD icons, team awareness and fair information Objective awareness UI — server carrier registry, ally HUD and minimap glyphs, neutral drop markers, ranked information tiers, spectator overlays, Harbor Siege 49→11% wrong-rotate refactor, decision table vs audio-only telegraphs, pitfalls, and checklist.
• Game defuse kit and utility equipment systems explained: buy economy, defuse channels and post-plant fairness Post-plant retake equipment — equipment slots, server defuse channel FSM, bare vs kit speed tiers, buy-phase pricing and fuse preview, drop-on-death pickup rules, scoreboard kit indicators, Harbor Strike 51→14% preventable-loss refactor, decision table vs timer-only defuse, pitfalls, and checklist.
• Game post-plant retake timing and geometry systems explained: fuse budgets, site layout and fair retakes Search-and-destroy retake fairness — fuse vs travel-time math, site geometry patterns, defender spawn routing, retake FSM, utility timing windows, Harbor Siege 58→12% unwinnable-retake refactor, decision table vs timer-only tuning, pitfalls, and checklist.
• Game control point and zone capture objective systems explained: tick scoring, contest rules and map flow Domination and Hardpoint objective design — KotH/Domination/Hardpoint FSMs, contest and ownership rules, tick scoring formulas, spawn flow, anti-stall decay and rotation, Harbor Arena 61→28% dead-time refactor, decision table vs bomb and TDM, pitfalls, and checklist.
• Sniper game design explained: ballistics, spotting and long-range tension Military sim vs arcade vs puzzle subgenres, spot-steady-breathe-fire-exfiltrate loops, bullet drop and wind holdover, spotting scopes and target priority, overwatch nest design, PvP vs PvE contracts, Harbor Overlook ridge worked example, subgenre decision table, pitfalls, and checklist.
• Parkour game design explained: traversal verbs, momentum and route reading Pure parkour vs open-world vs first-person vs lane endless subgenres, read-route-commit-recover loops, vault wall-run slide mantle verbs, momentum and assist systems, line readability, failure recovery, Harbor Rooftop Run worked example, subgenre decision table, pitfalls, and checklist.
• Walking simulator game design explained: exploration, narrative pacing and environmental story Contemplative vs horror vs tourism subgenres, explore-interpret-arrive loops, slow-walk movement as mechanic, environmental and audio-log storytelling, scenic reward beats, Harbor Coast lighthouse trail worked example, subgenre decision table, pitfalls, and checklist.
• Grand strategy and 4X game design explained: explore, expand, diplomacy and empire management Historical vs space vs nation-scale grand strategy subgenres, explore-expand-exploit-exterminate loops, tech and civic trees, diplomacy and casus belli, empire sprawl and anti-snowball tools, late-game pacing, Harbor Dynasty campaign worked example, subgenre decision table, pitfalls, and checklist.
• Life sim game design explained: needs, relationships, build mode and life stages Dollhouse sandbox vs text life sim subgenres, need and motive meters, time compression and life stages, build mode affordances, relationship drama engines, career and aspiration loops, Harbor Meadows worked example, subgenre decision table, pitfalls, and checklist.
• JRPG game design explained: party systems, ATB combat and story pacing Classic turn-based vs ATB vs action JRPG subgenres, town-dungeon-boss macro loops, party roles and job classes, bonding systems and limit breaks, Harbor Chronicles chapter worked example, subgenre decision table, pitfalls, and checklist.
• Loot shooter game design explained: gunplay, drop tables and endgame loops FPS vs third-person looter subgenres, shoot-loot-equip-upgrade loops, gunfeel with RPG stat layers, rarity tiers and targeted farming, seasonal endgame and co-op scaling, Harbor Vanguard strike worked example, subgenre decision table, pitfalls, and checklist.
• Text adventure game design explained: parser IF, choice fiction and world modeling Parser vs choice-based interactive fiction, room-object-verb world models, synonym grammars, fair puzzle cluing, narrative pacing in prose, Twine/Ink/Inform tooling, Harbor Archive mystery IF worked example, subgenre decision table, pitfalls, and checklist.
• Gacha mechanics design explained: banners, pity systems and ethical pull loops Weighted summon banners, rarity tiers and rate-up pools, soft and hard pity with 50/50 and sparking, duplicate ascension and shard systems, economy integration and regulation, Harbor Summon limited banner worked example, model decision table, pitfalls, and checklist.
• Beat-em-up game design explained: side-scrolling brawlers, combos and co-op flow Classic belt-scrollers vs modern revival subgenres, walk-forward-clear-advance loops, hitstun and juggle tuning, enemy wave choreography, co-op scaling, Harbor Alley stage-three worked example, subgenre decision table, pitfalls, and checklist.
• Board game design explained: turn structure, rules enforcement and digital adaptation Tabletop adaptations vs abstract strategy and worker placement, sequential and phased turns, hidden information and bluffing, async multiplayer, rules automation vs player agency, Harbor Parlor worked example, subgenre decision table, pitfalls, and checklist.
• Action RPG game design explained: real-time combat, loot loops and buildcraft Isometric vs third-person ARPG subgenres, explore-fight-loot-upgrade loops, stamina and cooldown combat, gear affixes and skill synergies, power-curve pacing, Harbor Ember act-two worked example, subgenre decision table, pitfalls, and checklist.
• Asymmetric multiplayer game design explained: one vs many, unequal objectives and fair fun 1v4 horror hunts, traitor co-op, commander and complementary-role modes, power budgets and counterplay, information asymmetry, matchmaking per side, Harbor Hunt archivist-vs-Curator worked example, subgenre decision table, pitfalls, and checklist.
• Party game design explained: minigames, couch chaos and social retention Board-game party vs anthology vs phone-controller subgenres, gather-compete-score-rotate loops, minigame rotation and player-count scaling, comeback mechanics and kingmaking, Harbor Bash board-night worked example, subgenre decision table, pitfalls, and checklist.
• Social deduction game design explained: hidden roles, bluffing and vote drama Mafia, task-impostor and Resistance subgenres, observe-discuss-commit loops, role information economy, discussion timers and voting rules, online voice UX, Harbor Parlor mystery night worked example, subgenre decision table, pitfalls, and checklist.
• Match-3 game design explained: cascades, level goals and mobile retention Swap-and-clear loops, board solvability, special tile combos, jelly and blocker objectives, saga map pacing, cascade juice, Harbor Bloom level-47 worked example, subgenre decision table, pitfalls, and checklist.
• Rhythm game design explained: charting, timing windows and audio sync Lane vs highway vs touch vs VR subgenres, listen-predict-input-feedback loops, chart density and telegraphing, judgment windows and latency calibration, Harbor Beat festival stage worked example, subgenre decision table, pitfalls, and checklist.
• Real-time strategy game design explained: macro, micro, economy and map control Classical vs asymmetric RTS subgenres, gather-build-expand-attack loops, worker economies and supply caps, unit counter triangles, map expansions and chokepoints, fog of war scouting, APM vs macro skill, Harbor Front 1v1 worked example, subgenre decision table, pitfalls, and checklist.
• Racing game design explained: arcade, simulation, kart handling and track flow Arcade vs simulation vs kart subgenres, drive-handle-compete loop, grip and drift models, racing lines and track flow, boost and rubber-banding, Harbor Circuit worked example, subgenre decision table, pitfalls, and checklist.
• Twin-stick shooter game design explained: aim, movement, waves and arena combat Classic twin-stick vs bullet heaven subgenres, dodge-shoot-survive loops, aim assist and input feel, arena readability at bullet density, wave spawning and escalation, weapon upgrade pacing, Harbor Outpost worked example, subgenre decision table, pitfalls, and checklist.
• Endless runner game design explained: procedural tracks, speed curves and mobile retention Lane vs freeform subgenres, dodge-collect-escalate loop, chunk-based procedural spawning, speed ramps and pity rules, swipe input and camera lead, meta-progression and continue ethics, Harbor Dash worked example, subgenre decision table, pitfalls, and checklist.
• Bullet hell and shmup game design explained: danmaku patterns, hitboxes and scoring Vertical and horizontal shoot-’em-ups — dodge-shoot loops, danmaku pattern primitives and readability, hitbox fairness, grazing and score systems, boss phase scripting, Harbor Skies worked example, subgenre decision table, pitfalls, and checklist.
• Hack-and-slash game design explained: action RPG combat, combos and loot loops Character-action vs loot ARPG vs musou subgenres, engage-clear-loot loops, combo graphs and dodge i-frames, enemy pack choreography, loot pacing, Harbor Blades worked example, subgenre decision table, pitfalls, and checklist.
• Hidden object game design explained: scene readability, lists and mobile retention List-based vs adventure-integrated vs map-driven subgenres, scan-find-collect loops, clutter budgets and occlusion rules, object list authoring, hint economies, chapter maps and energy pacing, Harbor Curiosity Museum worked example, subgenre decision table, pitfalls, and checklist.
• Merge game design explained: chains, board space and mobile retention Board vs map-driven vs order-queue subgenres, merge chains and generator economies, space pressure and bubble mechanics, quest pacing and narrative gates, meta progression and live events, Harbor Orchards worked example, subgenre decision table, pitfalls, and checklist.
• Word puzzle game design explained: daily Wordles, crosswords and letter feedback Daily guess, crossword, word search, Boggle and pangram subgenres, dictionary validation and server authority, color-blind-safe letter feedback, difficulty calibration and streak retention, Harbor Gazette daily puzzle worked example, subgenre decision table, pitfalls, and checklist.
• Immersive sim game design explained: player agency, systemic worlds and emergent solutions Observe-plan-execute loops, systemic simulation and composable rules, AI perception and sound propagation, multi-route level playgrounds, tool-based progression, Harbor Station infiltration worked example, subgenre decision table, pitfalls, and checklist.
• Visual novel game design explained: branching routes, flags and presentation Kinetic vs choice-based subgenres, read-select-advance loop, route maps and flag pipelines, ADV vs NVL presentation, sprite and CG pipelines, Harbor Letters mystery VN worked example, subgenre decision table, pitfalls, and checklist.
• Game narrative branching and consequence systems explained: flags, delayed payoff and player agency Branching dialogue state machines — boolean and numeric flags, immediate vs delayed consequences, illusion vs real choice, fail-forward forks, Harbor Chronicles council vote refactor, technique decision table vs VNs and reputation systems, pitfalls, and checklist.
• City builder game design explained: zoning, infrastructure and urban systems Land-use zoning and RCI demand, road and transit networks, utility chains, population and service coverage, municipal budgets, Harbor Metro Bay worked example, subgenre decision table, pitfalls, and checklist.
• Colony sim game design explained: settlers, needs, emergent crises and base building Frontier and facility subgenres, expand-assign-respond loop, colonist needs and mood, job prioritization, room quality, threat clocks, Harbor Haven crash-site worked example, subgenre decision table, pitfalls, and checklist.
• Tycoon game design explained: revenue loops, guest satisfaction and expansion pacing Attraction, service, transport, and production subgenres, plan-build-optimize-expand loop, revenue and expense modeling, guest satisfaction, scenario vs sandbox pacing, Harbor Park theme park worked example, subgenre decision table, pitfalls, and checklist.
• Fishing game design explained: casting, catch tables and collection loops Arcade timing, simulation realism and collection dex subgenres, cast-bite-fight-land loops, spawn tables and rarity pity, bait and tackle progression, Harbor Pier worked example, subgenre decision table, pitfalls, and checklist.
• Farming sim game design explained: seasons, crops, energy and cozy progression Day-and-season loops, crop calendars and quality tiers, energy budgets and automation upgrades, livestock and relationship systems, economy pacing, Harbor Orchard Valley worked example, subgenre decision table, pitfalls, and checklist.
• Dungeon crawler game design explained: floors, party roles and descent loops Vertical descent tension — floor pacing and room taxonomy, party composition and death rules, resource clocks, loot identification, boss gates, town-hub meta-loops, Harbor Ironvault worked example, subgenre decision table, pitfalls, and checklist.
• Turn-based tactics game design explained: grid combat, action points and squad roles Grid vs squad subgenres, action points and initiative, cover and elevation, class roles, overwatch and reactions, fog of war at encounter scale, permadeath stakes, Harbor Vanguard skirmish worked example, subgenre decision table, pitfalls, and checklist.
• Soulslike game design explained: stamina combat, checkpoints and punishing fairness High-consequence melee — stamina and poise, dodge i-frames, bonfire loops, death currency recovery, interconnected shortcuts, boss readability, Harbor Sanctum worked example, subgenre decision table, pitfalls, and checklist.
• Auto battler game design explained: shop loops, synergies, positioning and economy Draft-and-place combat — shop and reroll economies, unit tiers and trait synergies, board positioning geometry, interest and streak gold, async PvP matchmaking, Harbor Arena worked example, subgenre decision table, pitfalls, and checklist.
• Metroidvania game design explained: ability gating, map topology and backtracking loops Interconnected maps, hard and soft ability gates, shortcut unlocks, backtracking reward pacing, combat integration, Harbor Depths worked example, genre decision table, pitfalls, and checklist.
• Co-op game design explained: roles, scaling, communication and shared progression Couch vs online co-op subgenres, complementary roles and carry mitigation, difficulty scaling for party size, ping and callout systems, loot fairness, Harbor Siege worked example, subgenre decision table, pitfalls, and checklist.
• Split-screen game design explained: viewports, layouts, performance and couch multiplayer Shared vs divided cameras, horizontal and vertical layouts, dynamic splits and PiP, FOV and aspect compensation, dual-viewport rendering cost, per-pane HUD rules, Harbor Rumble couch refactor worked example, approach decision table, pitfalls, and checklist.
• Crossplay and cross-platform game design explained: pools, input parity and account linking Cross-play vs cross-save vs cross-progression, platform certification, input parity and aim assist, matchmaking pools and opt-in UX, account linking, voice and friends across consoles, Harbor Arena team shooter worked example, strategy decision table, pitfalls, and checklist.
• Game dedicated servers explained: hosting, tick rate and competitive multiplayer infrastructure Dedicated vs listen-server vs P2P, headless builds, tick rate and CPU budgeting, cloud and managed hosting, regional deployment, match lifecycle orchestration, Harbor Arena ranked refactor worked example, hosting decision table, pitfalls, and checklist.
• Game voice chat and spatial audio explained: WebRTC, proximity voice and team comms WebRTC and SFU topology, Opus codecs, push-to-talk vs voice activation, team vs proximity channels, spatial mixing and HRTF, moderation and privacy, Harbor Arena squad comms refactor worked example, architecture decision table, pitfalls, and checklist.
• Game rendering optimization explained: draw calls, batching and GPU culling Draw call bottlenecks, static and dynamic batching, GPU instancing, frustum and occlusion culling, material atlasing and shader variants, profiling workflow, Harbor Arena Season 2 refactor worked example, technique decision table, pitfalls, and checklist.
• Game netcode and multiplayer networking explained: prediction, rollback and lag compensation Client-server authority, tick rate and snapshots, client-side prediction and reconciliation, rollback netcode for fighters, lag compensation for hitscan, NAT traversal and relays, Harbor Arena 4v4 shooter refactor worked example, architecture decision table, pitfalls, and checklist.
• Game rollback netcode systems explained: savestates, resimulation and GGPO-style sync Fighting-game rollback design — input delay tuning, per-frame savestates, remote input prediction, resimulation caps, desync checksums, Harbor Brawl online refactor, technique decision table vs delay-based and lag compensation, pitfalls, and checklist.
• Game input lag and display latency systems explained: end-to-end timing, measurement and frame pacing Controller-to-pixel pipeline — poll timing, vsync and triple buffering, render-ahead caps, Reflex-style APIs, high-speed measurement, Harbor Brawl offline 89→41 ms refactor, technique decision table vs buffering-only fixes, pitfalls, and checklist.
• Extraction shooter game design explained: raid, loot, extract and persistent stash Raid-to-extract core loop, persistent stash vs match loot, gear fear and insurance, contested extraction zones, PvE scav balance, Harbor Raid worked example, subgenre decision table, pitfalls, and checklist.
• Battle royale game design explained: drop, loot, zone shrinking and last-player standing Drop phase and hot zones, loot tiers and RNG fairness, shrinking safe zones, squad knockdown and revives, map POIs and rotations, matchmaking at scale, Harbor Drop worked example, subgenre decision table, pitfalls, and checklist.
• Sandbox game design explained: creative freedom, systems and player expression Creative vs survival vs physics vs social subgenres, gather-modify-build loops, voxel and physics sandboxes, crafting gates, world persistence, multiplayer griefing, Harbor Blocks worked example, subgenre decision table, pitfalls, and checklist.
• MOBA game design explained: lanes, roles, objectives and team fights Classical vs brawler subgenres, lane and jungle topology, champion roles and power curves, gold and XP economies, vision control, objective timers, Harbor Clash worked example, subgenre decision table, pitfalls, and checklist.
• Sports game design explained: simulation, arcade, career modes and competitive fairness Simulation vs arcade vs management subgenres, stat modeling and physics, controls and skill expression, AI and difficulty, Ultimate Team and career loops, multiplayer fairness, Harbor League basketball worked example, decision table, pitfalls, and checklist.
• Game spectator mode and esports design explained: broadcast cameras, observer UI and tournament production Player POV vs directed broadcast cameras, stream delay and anti-sniping, observer fog and information boundaries, caster overlays and bracket tooling, Harbor Arena Season 3 tournament refactor worked example, approach decision table, pitfalls, and checklist.
• RPG game design explained: stats, builds, progression and player agency JRPG vs CRPG vs action RPG subgenres, explore-fight-grow-choose loop, stat systems and build variety, loot and economy pacing, party and companion design, narrative agency, Harbor Quest chapter worked example, subgenre decision table, pitfalls, and checklist.
• Simulation game design explained: city builders, tycoons, life sims and systems loops Subgenre overview, core observe-diagnose-intervene loop, agent vs aggregate modeling, feedback loops and bottlenecks, time compression, UI for complexity, economy pacing, emergence vs scripting, Harbor Town city-builder worked example, decision table, pitfalls, and checklist.
• Strategy game design explained: RTS, turn-based, 4X and grand strategy Subgenre time scales, gather-build-expand-conquer loops, resource economies, unit counter triangles, map chokepoints, fog of war and scouting, AI scaling, multiplayer sync, Iron Pass skirmish worked example, decision table, pitfalls, and checklist.
• Fighting game design explained: neutral, mixups, roster balance and netcode 2D vs 3D subgenres, neutral and spacing archetypes, offense and defense layers, character roster design, training modes, rollback netcode, Harbor Brawl worked example, subgenre decision table, pitfalls, and a production checklist.
• Shooter game design explained: FPS, TPS, arena, battle royale and extraction loops Subgenre loops and TTK bands, FPS vs TPS camera fairness, movement and aim feel, map sightlines and cover, weapon roles, AI and PvEvP, multiplayer netcode and playlists, Harbor Watch worked example, decision table, pitfalls, and checklist.
• 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 weapon systems explained: gunplay, recoil, spread and time-to-kill Shooter weapon design — hitscan vs projectile ballistics, recoil and spread tuning, aim assist curves, TTK and damage falloff, reload economy, loadout roles, multiplayer hit validation, genre patterns, and a production checklist.
• Game combo systems explained: chains, cancels, buffers and style meters Combo design across genres — link windows, cancel rules, input buffers, damage scaling, juggle limits, style rank meters, combo breakers, training modes, multiplayer authority, accessibility shortcuts, and a production checklist.
• Game combo breaker systems explained: burst, DP escapes, infinite prevention and comeback design Defensive escape design — burst and reversal taxonomy, meter costs and cooldowns, juggle air tech, infinite loop caps, PvE vs PvP tuning, Harbor Siege duel refactor, technique decision table vs poise-only defense, pitfalls, and checklist.
• Game super meter and ultimate ability systems explained: build, spend and spectacle Combat resource design — meter gain on hit and block, tiered EX supers and ultimates, team meters, desperation bursts, Harbor Ruins bridge boss refactor, genre decision table, pitfalls, and checklist.
• Game cooldown systems explained: timers, charges, GCD and ability pacing Ability time gates — flat timers, charge stacks, global cooldown, CDR caps, shared category CDs, Harbor Siege support refactor, technique decision table vs super meters, pitfalls, and checklist.
• Game install super and install mode systems explained: powered states, timer drain and movelist morphing Sustained power spike design — timer and hit-drain models, movelist morphing, aura buffs, punish windows, Harbor Brawl install refactor, technique decision table vs burst supers and stance switch, pitfalls, and checklist.
• Game super cinematic freeze systems explained: hitstop, timer pause and super flash Fighting-game super presentation design — global hitstop extension, timer freeze vs simulation pause, background dim and camera zoom, combo continuation rules, rollback sync, Harbor Brawl super flash refactor, technique decision table vs slow-motion dilation, pitfalls, and checklist.
• Game match format and round systems explained: best-of sets, timers and win conditions Competitive structure design — Bo1/Bo3/Bo5 set length, round timers and sudden-death overtime, KO and timeout win conditions, side selection between games, ranked vs tournament presets, Harbor Brawl format refactor, technique decision table vs endless rounds, pitfalls, and checklist.
• Game ring-out and stage KO systems explained: blast zones, kill percent and edge pressure Spatial win condition design — blast zones and walk-off ledges, kill-percent knockback scaling, throw ring-out gates, corner carry and edge-guard layers, Harbor Siege cliff stage refactor, technique decision table vs health-only KO, pitfalls, and checklist.
• Game tag-team and assist call systems explained: swap rules, assist layers and team order design Team fighter design — hard vs soft tags, assist call taxonomy and cooldown economies, hitstun scaling on assists, point/anchor roles, Harbor Siege 3v3 refactor, technique decision table vs solo roster, pitfalls, and checklist.
• Game melee combat systems explained: hit detection, poise, lock-on and weapon archetypes Close-quarters combat design — sweep hitboxes, startup/active/recovery frames, poise and stagger, knockback curves, soft lock-on cameras, weapon reach and weight classes, enemy telegraphs, Harbor Ruins brawler refactor worked example, genre decision table, pitfalls, and checklist.
• Game stance switch combat systems explained: offensive, defensive and moveset morphing Melee depth without weapon swap — high/mid/low and power stance taxonomy, transition costs and cancel windows, stance-gated light strings, enemy telegraphed stances, Harbor Siege duel refactor, technique decision table vs weapon swap, pitfalls, and checklist.
• Game hard and soft knockdown systems explained: OTG rules, forced stand and oki payoff Fighting-game knockdown taxonomy — hard vs soft vs forced-stand, OTG eligibility and frame windows, okizeme payoff tiers, juggle ender interactions, Harbor Brawl knockdown refactor, technique decision table vs single knockdown type, pitfalls, and checklist.
• Game on-the-ground attack systems explained: OTG windows, sweeps and oki extensions Fighting-game OTG design — sweep/special/launcher/throw taxonomy, knockdown window math, prone hurtbox contracts, oki layering before meaties, Harbor Brawl OTG refactor, technique decision table vs meaty-only oki, pitfalls, and checklist.
• Game ground bounce systems explained: floor pop, juggle relaunch and OTG bridges Fighting-game floor bounce design — pop taxonomy, bounce height math, juggle relaunch budgets, OTG bridge rules, Harbor Brawl ground-bounce refactor, technique decision table vs hard-knockdown enders, pitfalls, and checklist.
• Game wake-up and getup combat systems explained: knockdown, okizeme and reversal options Knockdown state machines, quick rise vs delayed getup, directional tech rolls, reversal wake-ups, meaty okizeme and frame traps, Harbor Siege duel refactor, technique decision table vs standing-only combat, pitfalls, and checklist.
• Game tech roll systems explained: directional recovery, i-frames and oki escape Fighting-game tech roll design — knockdown recovery windows, back/forward/neutral rolls, invincibility and punish frames, corner wall clamp, oki coverage matrices, mash protection, Harbor Siege refactor, technique decision table vs quick-rise-only, pitfalls, and checklist.
• Game tech chase systems explained: knockdown reads, oki layering and corner carry Fighting-game tech chase design — attacker read layers after tech rolls, delayed and neutral tech coverage, throw chase routes, corner carry geometry, Harbor Siege oki refactor, technique decision table vs meaty-only setups, pitfalls, and checklist.
• Game air tech and recovery systems explained: juggle escape, i-frames and air oki Fighting-game air recovery design — techable vs untechable air knockdowns, directional air tech variants, invincibility and vulnerable frames, juggle ender interactions, air okizeme coverage matrices, Harbor Brawl refactor, technique decision table vs ground-only recovery, pitfalls, and checklist.
• Game counter-attack systems explained: counter-hits, whiff punishes and frame traps Counter-hit flags and detection pipeline, whiff-punish windows, frame-trap strings, riposte vs raw counter paths, Harbor Siege duel refactor, technique decision table vs flat damage scaling, pitfalls, and checklist.
• Game reflect and parry systems explained: projectile deflection, attack reversal and risk-reward defense Projectile vs melee vs beam reflect taxonomy, timing windows and coverage arcs, ownership transfer and damage policy, multi-hit routing, Harbor Siege mage duel refactor, technique decision table vs flat block, pitfalls, and checklist.
• Game ranged combat systems explained: hitscan, spread, recoil, reload loops and engagement distance Shooter and action-RPG gunplay design — hitscan vs ballistics at the gameplay layer, spread bloom and recoil patterns, ADS vs hipfire, damage falloff and penetration, tactical vs empty reload, TTK budgeting, Harbor Outpost rifle refactor worked example, genre decision table, pitfalls, and checklist.
• Game ammo and reload systems explained: magazines, tactical reloads, reserve pools and combat pacing Shooter resource pacing — magazine capacity and time-to-empty, tactical vs empty reload splits, cancel windows and animation commit frames, auto-reload rules, weapon swap carryover, pickup encounter budgeting, special ammo types, Harbor Outpost SMG corridor refactor, technique decision table, pitfalls, and checklist.
• Game weapon swap and holster systems explained: draw FSM, switch speed and loadout pacing Shooter weapon-change design — holster and draw FSM, number-key vs wheel vs quick-swap input, cancel windows and animation blends, per-slot ammo carryover, draw-vs-reload timing budgets, Harbor Arsenal 47→11% swap-death refactor, technique decision table vs instant switch, pitfalls, and checklist.
• Game fire mode selector systems explained: semi-auto, burst and full-auto tuning Shooter cadence design — semi, burst and full-auto FSMs, per-mode RPM and recoil profiles, hold vs tap input, ammo economy coupling, mode persistence, Harbor Outpost 58→19% corridor wipe refactor, technique decision table vs always-auto, pitfalls, and checklist.
• Game recoil and spread systems explained: bloom, recovery curves, ADS tuning and shooter feel Shooter accuracy design — deterministic recoil patterns vs random bloom, first-shot accuracy, spread accumulation and recovery delay, ADS and stance modifiers, movement penalties, Harbor Ruins rooftop rifle refactor, technique decision table vs aim assist, pitfalls, and checklist.
• Game counter-strafe and movement accuracy penalty systems explained: velocity spread, decel tuning and peek skill Tactical shooter movement accuracy — velocity-to-spread curves, counter-strafe friction, settle gates, accuracy_band replication, peek archetypes, Harbor Vanguard 52→14% wide-peek miss refactor, decision table vs spread-only, pitfalls, and checklist.
• Game bullet hit tagging and movement slow penalty systems explained: tag stacks, duel pacing and wide-peek balance Enemy-applied movement slow — server tag FSM, weapon and body-zone modifiers, stack caps and decay, armor coupling, Harbor Flux 56→11% wide-peek escape refactor, decision table vs accuracy-only, pitfalls, and checklist.
• Game aim down sights and hip fire systems explained: ADS FSM, spread curves and engagement bands Shooter aim-mode design — toggle vs hold ADS, enter/exit FSM and sprint cancel, hip vs ADS spread multipliers, movement and optic zoom tiers, engagement distance bands, Harbor Depot CQB refactor 54→19% miss rate, technique decision table vs always-ADS, pitfalls, and checklist.
• Game scope, optic zoom and magnification systems explained: FOV scaling, ADS tiers and long-range readability Tactical shooter optics — magnification taxonomy, FOV vs true zoom, per-optic ADS timing and sensitivity tables, scope sway and breath hold, glint visibility, Harbor Ridge 48→15% long-range dispute refactor, decision table vs flat ADS, pitfalls, and checklist.
• Game corner peek and lean mechanics systems explained: hitbox exposure, peeker's advantage and fair angles Tactical angle design — jiggle and shoulder peek taxonomy, lean FSM, camera vs split hitbox sync, peeker's advantage math, lag-comp pose rewind, Harbor Ridge 58→12% angle-dispute refactor, decision table vs camera-only lean, pitfalls, and checklist.
• Game mouse sensitivity, ADS tuning and aim assist systems explained: eDPI, FOV scaling and controller curves Shooter input tuning — cm/360 and eDPI math, hip vs ADS multipliers and per-zoom tables, FOV sensitivity scaling, controller deadzones and layered aim assist, Harbor Crest 41→14% overflick refactor, technique decision table vs unified slider, pitfalls, and checklist.
• Game crosshair and reticle customization systems explained: dynamic spread, hit feedback and player tuning Shooter reticle design — static vs dynamic spread arms, hip vs ADS optic profiles, hit-marker layering, colorblind presets, Harbor Crest 52→16% misread-shot refactor, technique decision table vs fixed dot, pitfalls, and checklist.
• Game suppression fire and pin-down systems explained: volume, peek timers and squad tactics Tactical shooter pin design — volume-of-fire suppression meters, near-miss accumulation and decay, flinch duck and pin FSM, peek cooldown gating, LMG vs rifle weights, Harbor Plaza crossfire refactor 68→22% squad wipe rate, technique decision table vs raw DPS, pitfalls, and checklist.
• Game ballistic penetration and wallbang systems explained: material tiers, damage falloff and angle rules Tactical shooter penetration design — material hardness tiers, weapon penetration power, per-layer damage falloff, oblique angle and ricochet rules, defender feedback, Harbor Depot 41→14% hard-cover camp refactor, technique decision table vs binary hitscan, pitfalls, and checklist.
• Game crouch, prone and stance systems explained: accuracy, silhouette and movement tradeoffs Shooter posture design — stand/crouch/prone state machines, transition timing and input priority, spread and recoil modifiers, cover height and capsule silhouette, stealth footstep loudness, Harbor Ruins warehouse refactor, technique decision table vs cover and locomotion, pitfalls, and checklist.
• Game footstep and noise detection systems explained: surface audio, hearing radius and stealth alerts Stealth audio design — surface material tags and loudness multipliers, locomotion and stance bands, AI hearing radius with falloff and occlusion, discrete vs continuous noise, alert propagation, Harbor Ruins patrol corridor refactor, technique decision table vs vision-only stealth, pitfalls, and checklist.
• Game lockpicking systems explained: minigames, difficulty tiers and key economy RPG door bypass design — lock difficulty tiers, pin-tumbler and timing-bar minigame archetypes, lockpick consumable economy, soft vs hard fail and jam meters, stealth noise integration, Harbor Chronicles vault refactor, technique decision table vs hacking and key-fetch quests, pitfalls, and checklist.
• Game slow motion and time dilation systems explained: bullet time, meters and tactical pause Action combat time design — global vs localized time scale, meter economies and skill-triggered dilation, AI and projectile tick behavior, VFX/audio presentation, Harbor Ruins frost knight parry refactor, technique decision table vs hitstop and full pause, pitfalls, and checklist.
• Game charge attack systems explained: hold timing, tiers, interrupts and risk-reward Action combat hold design — charge state machines, tiered damage curves, interrupt and super-armor rules, telegraphs and audio ticks, stamina gates, Harbor Ruins greatsword refactor, technique decision table vs combos and super meters, pitfalls, and checklist.
• Game focus attack and armor charge systems explained: hold armor, crumple payoffs and counter-hit routes Fighting-game neutral commitment design — hold-to-armor FSM, single-hit absorption tiers, L1/L2/L3 release profiles, counter-hit crumple payoffs, overhead and low variants, Harbor Siege neutral refactor, technique decision table vs plain charge attacks, pitfalls, and checklist.
• Game hyper armor and super armor explained: interrupt frames, attack phases and armor break Action combat armor design — super vs hyper armor tiers, attack phase FSMs, interrupt priority and armor-break tools, player-enemy asymmetry, Harbor Ruins brute refactor, technique decision table vs poise and i-frames, pitfalls, and checklist.
• Game backstab and stealth takedown systems explained: rear cones, prompts and body handling Stealth payoff design — rear angle validation, takedown FSM and prompt windows, lethal vs non-lethal branches, corpse hiding and discovery escalation, Harbor Dockyard guard refactor, technique decision table vs open combat, pitfalls, and checklist.
• Game finisher and execution systems explained: trigger gates, cinematic kills and reward pacing Combat payoff design — HP and stagger trigger gates, prompt FSM and input buffering, cinematic vs in-engine kills, invulnerability bubbles and phase guards, Harbor Ruins elite refactor, technique decision table vs regular kills and QTE, pitfalls, and checklist.
• Game security camera and surveillance systems explained: frustums, sweeps and blind spots Environmental stealth detectors — fixed and panning frustums, sweep timing and telegraphs, blind-spot authoring, monitor feeds and guard escalation, disable and hack loops, Harbor Dockyard warehouse refactor, technique decision table vs guard-only and laser grids, pitfalls, and checklist.
• Game enemy leash and patrol systems explained: tether radius, waypoints and reset behavior Open-world AI pacing — tether points and hard leash radii, alert vs chase distance, waypoint loop patrols, return-to-path FSM, Harbor Dockyard stealth refactor, technique decision table vs static guards and random roam, pitfalls, and checklist.
• Game photo mode systems explained: free camera, posing, filters and share pipelines Virtual photography design — simulation freeze and time control, detached orbit cameras, character posing and animation scrubbing, DOF and exposure stacks, HUD hiding and 4K export, Harbor Chronicles vista refactor, technique decision table vs replay and cutscenes, pitfalls, and checklist.
• Game zipline traversal systems explained: cable splines, attach/detach and momentum design Fixed-cable traversal — spline authoring and gravity speed curves, entry gates and unlock gating, brake and lean control, dismount momentum, Harbor Highlands ridge refactor, technique decision table vs grapple and fast travel, pitfalls, and checklist.
• Game wall-run traversal systems explained: surface detection, momentum and corner transfers Vertical surface traversal — eligibility probes and speed gates, attach FSM and gravity curves, stamina and distance caps, corner transfers and chain exits, Harbor Rooftop gap refactor, technique decision table vs mantling and grapple, pitfalls, and checklist.
• Game sprint and stamina movement systems explained: speed tiers, drain curves and traversal pacing Walk/jog/sprint tier taxonomy, hold vs toggle input, stamina drain and regen curves, acceleration and surface modifiers, combat vs exploration policies, Harbor Outpost marsh refactor, technique decision table vs always-fast movement, pitfalls, and checklist.
• Game ladder climb systems explained: mount detection, climb FSM and dismount transitions Ladder mount cones and raycast entry, climb finite-state machine, rung snap and continuous velocity, top/bottom/side dismount rules, combat and camera policies, Harbor Siege tower refactor, technique decision table vs mantling and grapple, pitfalls, and checklist.
• Game air dash movement systems explained: burst mobility, charges and platforming feel Cardinal vs omni air dash taxonomy, charge stacks and cooldown gates, direction locking and momentum carry, traversal vs combat policies, Harbor Rooftop gap refactor, technique decision table vs dodge roll and double jump, pitfalls, and checklist.
• Game double jump movement systems explained: apex shaping, charges and vertical reach Vertical vs omni second jump taxonomy, apex shaping and gravity curves, charge refresh models, coyote and buffer integration, Harbor Spire shaft refactor, technique decision table vs air dash and wall-run, pitfalls, and checklist.
• Game slide movement systems explained: ground slides, momentum and combat cancels Ground vs crouch slide taxonomy, velocity inheritance and friction curves, capsule collision and clearance, slide-jump cancels, stamina gating, Harbor Quarry tunnel refactor, technique decision table vs dodge roll and sprint, pitfalls, and checklist.
• Game wall-jump movement systems explained: ricochet impulses, chain limits and vertical ascent Perpendicular vs ricochet wall-jump taxonomy, contact probes and impulse curves, chain limits and stamina, double-jump interaction, Harbor Citadel shaft refactor, technique decision table vs wall-run and air dash, pitfalls, and checklist.
• Game mount and rideable systems explained: summon, movement feel and open-world traversal Mount traversal design — ground and flying rideables, summon and dismiss rules, stamina and terrain gates, mounted combat boundaries, Harbor Chronicles plains refactor, technique decision table vs fast travel and on-foot locomotion, pitfalls, and checklist.
• Game quest log and journal systems explained: objectives, pinning and player clarity RPG quest tracking — quest registry and step predicates, verb-first journal UI, pin and waypoint integration, zone rings and HUD strips, Harbor Chronicles abandonment refactor, technique decision table vs HUD-only trackers, pitfalls, and checklist.
• Game ping and waypoint marker systems explained: callouts, off-screen indicators and co-op clarity Spatial communication design — ping taxonomy and wheels, world-space vs screen-space markers, off-screen edge arrows, multiplayer replication and spam caps, clutter budgets, Harbor Siege Bastion of Ash refactor, technique decision table vs minimap-only, pitfalls, and checklist.
• Game emote and gesture systems explained: social expression, animation sync and multiplayer communication Nonverbal co-op communication — full-body vs upper-body taxonomy, radial wheels and hotbars, animation layering and cancel rules, multiplayer replication and spam caps, Harbor Siege social hub refactor, technique decision table vs text chat only, pitfalls, and checklist.
• Game radial menu systems explained: wheels, sectors and hold-to-select UX Circular action UI — hold-to-aim vs tap-toggle vs flick-select taxonomy, angle-to-sector math and dead zones, slow-time policy, weapon and emote wheels, Harbor Siege RadialDirector refactor, technique decision table vs linear hotbars, pitfalls, and checklist.
• Game fast travel and teleport systems explained: waypoints, costs and open-world pacing Open-world travel design — discovery unlocks and hub networks, map menu vs diegetic pads, time and currency costs, streaming-safe spawns, Harbor Chronicles beacon refactor, technique decision table vs mounts and checkpoints, pitfalls, and checklist.
• Game swimming, diving and underwater systems explained: buoyancy, oxygen and traversal feel Water traversal design — wade, surface swim and submerged states, buoyancy and drag tuning, oxygen and pressure meters, underwater combat and interaction, Harbor Outpost reef refactor, technique decision table vs boats and fast travel, pitfalls, and checklist.
• Game water current and river flow traversal systems explained: flow fields, surface drift and upstream puzzles River and current design — spline-directed flow, surface vs submerged drift, upstream stamina and eddies, whirlpool telegraphs, tidal phase cycles, Harbor Delta 38→81% quest refactor, technique decision table vs wind zones and conveyors, pitfalls, and checklist.
• Game monkey bar and overhead traversal systems explained: hand-to-hand timing, brachiation and chain momentum Playground and warehouse overhead routes — discrete rings vs continuous rails, mount FSM and coyote grab, tap rhythm vs hold crawl, stamina slip telegraphs, Harbor Playground 52→89% clear-rate refactor, technique decision table vs ladder and rope swing, pitfalls, and checklist.
• Game jetpack and aerial thrust systems explained: fuel, overheat and vertical mobility Smelter catwalk and chimney climbs — ignition FSM and coyote ignite, physics thrust vs arcade float, fuel and overheat meters, horizontal vectoring and landing recovery, Harbor Foundry 67→14% fall-death refactor, technique decision table vs glider and air dash, pitfalls, and checklist.
• Game skill check and dice roll systems explained: DCs, modifiers and narrative stakes RPG resolution design — d20 vs dice pools vs percentile, difficulty classes and modifier caps, opposed rolls and passive scores, advantage and reroll economies, hidden vs visible feedback, critical outcomes and fail-forward, Harbor Chronicles council persuasion refactor, technique decision table vs QTEs and stat thresholds, pitfalls, and checklist.
• Game dodge roll and invincibility frames explained: i-frames, stamina, perfect dodges and netcode Defensive combat design — roll vs dash vs sidestep archetypes, invincibility frame timing, stamina and cooldown gates, perfect dodge rewards, poise and hitstun interaction, Harbor Ruins boss gauntlet refactor worked example, genre decision table, pitfalls, and checklist.
• Game parry and block systems explained: guard, timing windows, chip damage and ripostes Stationary defense design — hold block vs timed parry, guard coverage and attack typing, chip damage and stamina drain, poise and guard break, perfect parry ripostes, enemy telegraphs, Harbor Ruins duelist refactor worked example, genre decision table, pitfalls, and checklist.
• Game reversal attack systems explained: wake-up DPs, EX reversals and oki counterplay Wake-up defensive attack design — reversal priority flags, invincibility tiers, EX and super reversals, safe jumps and delayed meaties, Harbor Brawl oki refactor, technique decision table vs mash-only defense, pitfalls, and checklist.
• Game invincibility frame systems explained: i-frames, hurtbox gaps and intentional whiff windows Invuln taxonomy — full vs partial hurtbox disable, reversal and backdash i-frames, throw and projectile immunity tiers, post-knockdown wake windows, rollback-safe scheduling, Harbor Brawl oki refactor, technique decision table vs armor-only, pitfalls, and checklist.
• Game midscreen neutral systems explained: footsies, spacing bands and poke ranges Grounded neutral design — spacing bands, poke and counterpoke taxonomy, approach and retreat vectors, whiff-punish economy, strike-throw handoff, anti-air conditioning, Harbor Brawl neutral refactor, technique decision table vs jump-in-only offense, pitfalls, and checklist.
• Game fakeout, bait and punish systems explained: conditioning, respect and neutral reads Psychological neutral layer — movement and attack feints, bait FSM and cancel windows, conditioning establish-respect-break loops, punish routing tiers, Harbor Brawl mash-on-feint 67→31% and bait conversion 12→44%, technique decision table vs whiff-punish and frame traps, pitfalls, and checklist.
• Game short hop and tiger knee movement systems explained: SHFF, instant air and low aerials Aerial movement layer — jump squat frames, variable hop height, SHFF fast fall, tiger knee and instant air specials, platform vs trad fighter models, Harbor Brawl aerial refactor, technique decision table vs full-hop-only offense, pitfalls, and checklist.
• Game empty hop movement systems explained: jump bait, landing mixups and anti-air conditioning Neutral movement layer — empty hop vs jump-in, hop arc phases and landing recovery, empty low and crossup routes, anti-air conditioning loops, reversal gap interaction, Harbor Brawl neutral refactor, technique decision table vs jump-in-only offense, pitfalls, and checklist.
• Game guard cancel combat systems explained: blockstun escapes, alpha counters and defensive cancels Fighting-game defensive cancel design — blockstun-to-special routes, reversal and alpha counter windows, guard mobility cancels, meter costs and whiff recovery, Harbor Brawl refactor, technique decision table vs parry-only and burst-only defense, pitfalls, and checklist.
• Game guard break systems explained: posture meters, stamina collapse and break punishes Anti-turtle defense design — posture and poise depletion, stamina guard collapse, guard-crush moves, chip lethal, break-state FSMs, punish windows, Harbor Siege duel refactor, technique decision table vs flat block, pitfalls, and checklist.
• Game guard crush systems explained: move properties, block bypass and anti-turtle pressure Per-move block interaction design — startup and active guard-crush flags, stance-damage stacking, guard stagger tiers, perfect-guard nullification, Harbor Siege blockstring refactor, technique decision table vs posture-only and chip-only defense, pitfalls, and checklist.
• Game chip damage and guard damage systems explained: blocked hits, chip lethal and anti-turtle design Life tax on successful blocks — chip ratios, guard damage vs posture, chip lethal thresholds, special chip rules, perfect-guard immunity, Harbor Siege duel refactor, technique decision table vs guard-break-only defense, pitfalls, and checklist.
• Game just guard and perfect guard systems explained: timing windows, frame advantage and anti-chip design Impact-timing block rewards — just-guard windows, frame advantage bonuses, chip immunity and pushback reduction, meter rewards, blockstring counterplay, Harbor Siege duel refactor, technique decision table vs hold-block-only defense, pitfalls, and checklist.
• Game hold parry and drive parry systems explained: sustained defense, meter drain and walk-through pressure Sustained parry design — hold-state absorption, per-hit tension drain and burnout, walk-through blockstrings, release recovery and throw counterplay, Harbor Siege rushdown refactor, technique decision table vs just guard and reflect parry, pitfalls, and checklist.
• Game recoverable health and blue life systems explained: white damage, recovery decay and round tension Health bar layering — white vs blue damage pools, on-hit and passive recovery rates, idle decay and knockdown hardening, chip and guts interaction, Harbor Brawl comeback refactor, technique decision table vs flat HP and regen, pitfalls, and checklist.
• Game red parry systems explained: blockstun timing, frame advantage and blockstring breaks Blockstun parry windows — late-blockstun and gap models, per-string budgets, frame advantage on success, blockstring counterplay, Harbor Siege pressure refactor, technique decision table vs just guard and full parry, pitfalls, and checklist.
• Game grab and throw systems explained: command grabs, throw techs and grappler design Anti-block offense design — regular throws vs command grabs, throw techs and breakaway meters, grab hitbox priority, wall splats and okizeme, grappler kit structure, Harbor Siege refactor, technique decision table vs block-only defense, pitfalls, and checklist.
• Game universal overhead attack systems explained: macro inputs, blockstring mixups and anti-crouch design Roster-wide overhead layer — macro input patterns, startup and gap conventions, blockstring cancel integration, throw coverage, fuzzy guard counterplay, Harbor Brawl mixup refactor, technique decision table vs per-move overheads, pitfalls, and checklist.
• Game mixup and high/low combat systems explained: overheads, lows and strike-throw pressure Offensive ambiguity design — high/mid/low attack layers, blockstring pressure and frame traps, strike-throw mixups, conditioning and respect, okizeme meaties, Harbor Siege duel refactor, technique decision table vs flat damage scaling, pitfalls, and checklist.
• Game crouch block and high/low guard stance systems explained: standing guard, low profile and overhead vulnerability Defensive stance design — standing vs crouching guard FSM, mid/low/overhead block resolution, hurtbox profile coupling, blockstun stance lock and fuzzy guard, Harbor Brawl overhead mixup refactor, technique decision table vs auto-block and unified guard, pitfalls, and checklist.
• Game sweep and low-profile attack systems explained: trip attacks, footsies and knockdown setups Ground-level offense design — sweep taxonomy, standing-foot hitboxes, low-profile projectile interaction, OTG trip rules, footsies spacing, Harbor Brawl sweep refactor, technique decision table vs generic low pokes, pitfalls, and checklist.
• Game low crush and high crush attack systems explained: hurtbox evasion, mixups and footsies Vertical evasion design — low crush ducking under standing highs, high crush rising over sweeps, per-frame hurtbox height phases, mixup layering with overheads and dash approaches, Harbor Brawl crush refactor, technique decision table vs flat hitboxes, pitfalls, and checklist.
• Game Roman Cancel and movement cancel systems explained: RC types, slowdown and neutral extensions Universal meter cancel design — whiff/on-hit/on-block RC taxonomy, global slowdown windows, drift caps, meter economy, Harbor Brawl RC refactor, technique decision table vs special-cancel-only routes, pitfalls, and checklist.
• Game kara cancel and proximity cancel systems explained: range extension, throw tech and spacing Startup movement kara cancels — kara throw and kara special range extension, proximity normals and guard bands, input parsing, Harbor Brawl grappler refactor, technique decision table vs plain special cancels, pitfalls, and checklist.
• Game landing lag and recovery systems explained: touchdown frames, autocorrect and cancel windows Touchdown frame taxonomy — hard vs soft landing, attack landing tiers, crossup autocorrect and facing, landing special and dash cancel windows, safe jump advantage math, Harbor Brawl movement refactor, technique decision table vs frame-data-only docs, pitfalls, and checklist.
• Game safe jump timing systems explained: wakeup advantage, landing frames and AA evasion Knockdown oki layer — advantage budget math, jump arc vs reversal active frames, meaty vs empty safe jumps, short-hop and crossup variants, Harbor Brawl oki refactor, technique decision table vs meaty-only pressure, pitfalls, and checklist.
• Game setplay and frame kill systems explained: timed setups, advantage routing and oki routes Knockdown setplay layer — frame-kill filler math, route trees and branching, neutral reset setplay off plus frames, auto-timed training tools, Harbor Siege oki refactor 14→36% damage share, technique decision table vs random meaties, pitfalls, and checklist.
• Game fuzzy guard combat systems explained: delayed block, fuzzy jump and mixup defense Defensive timing layer — delayed crouch and stand block, blockstring respect tables, fuzzy jump vs safe jumps, fuzzy throw tech, input-buffer interaction, Harbor Brawl defense refactor, technique decision table vs hold-down block, pitfalls, and checklist.
• Game option select combat systems explained: jump OS, throw coverage and conditioning loops Multi-outcome mixup design — jump throw OS, safe jump and crossup OS, strike/throw shimmy OS, reversal and meaty OS, coverage maps and spacing bands, Harbor Brawl Latch refactor, technique decision table vs random mixups, pitfalls, and checklist.
• Game combo damage scaling systems explained: proration curves, starter penalties and combo caps Combo balance design — per-hit decay, starter and move proration, damage floors and hard caps, hitstun alignment, Harbor Brawl Anchor refactor, technique decision table vs flat damage, pitfalls, and checklist.
• Game guts, rage and comeback systems explained: low-health scaling, life-lead buffs and snowball prevention Comeback balance design — guts damage reduction curves, rage threshold FSM, life-lead snowball brakes, combo scaling interaction, Harbor Brawl one-touch kill refactor, technique decision table vs flat health pools, pitfalls, and checklist.
• Game combo reset systems explained: restand routes, scaling breakpoints and mid-combo pressure Mid-combo routing design — restand and launcher resets, scaling breakpoint knees, side-switch and wall-routing resets, oki handoff, infinite prevention, Harbor Brawl reset refactor, technique decision table vs linear scaling-only combos, pitfalls, and checklist.
• Game plus-on-block frame advantage systems explained: blockstun gaps, punish windows and pressure tiers Pressure math design — blockstun advantage tiers, tick throws and meaties, effective corner spacing, frame traps from minus endpoints, Harbor Brawl advantage refactor, technique decision table vs blockstrings only, pitfalls, and checklist.
• Game damage scaling and proration systems explained: combo economy, minimum damage and route balance Combo damage economy — per-hit scaling curves, move proration tables, minimum damage floors, reset generation penalties, Harbor Brawl scaling refactor, technique decision table vs juggle limits only, pitfalls, and checklist.
• Game meter gain and spending economy systems explained: gauge income, EX costs and round pacing Resource pacing design — on-hit and on-block gain tables, whiff penalties, EX and super tier costs, shared drive gauge coupling, Harbor Siege meter refactor, technique decision table vs cooldown-only resources, pitfalls, and checklist.
• Game counter-hit systems explained: startup windows, stun bonuses and punish routes Fighting-game counter design — startup vs recovery detection, damage and hitstun multipliers, crumple and launch properties, Harbor Brawl counter state refactor, technique decision table vs counter-attack only, pitfalls, and checklist.
• Game crush counter systems explained: startup intercepts, crumple states and wall routes Slow-normal neutral design — crush eligibility and startup priority, crumple and wall splat payoffs, detection pipeline vs counter-hit and trade, Harbor Brawl heavy-check refactor, technique decision table, pitfalls, and checklist.
• Game punish counter systems explained: attacker-state detection, bonus scaling and neutral reads Modern neutral tax design — attacker-state flags, startup/active/recovery eligibility, damage and hitstun tiers, trade modifiers, Harbor Brawl invisible-damage refactor, technique decision table vs counter-hit and whiff punish, pitfalls, and checklist.
• Game footwork and spacing systems explained: walk speed, backdash and micro-range control Grounded neutral substrate — forward/back walk tiers, backdash invulnerability, crouch walk hurtbox shifts, hover range and poke overlap, Harbor Brawl spacing refactor, technique decision table vs dash and wavedash, pitfalls, and checklist.
• Game backdash turnaround buffer systems explained: retreat invuln, buffered inputs and cross-under spacing Retreat buffer layer — backdash FSM and invuln tiers, blockstun buffer queues, turnaround attack routing, kara-backdash range, shimmy and tick-throw defense, Harbor Brawl throw-loop refactor 36→58%, technique decision table vs walk-back and wavedash, pitfalls, and checklist.
• Game attack priority and trading systems explained: simultaneous hits, clanks and neutral trades Same-frame hitbox resolution — L/M/H priority tiers, trade vs win-out vs clank, projectile and armor interactions, Harbor Brawl neutral refactor, technique decision table vs counter-hit and super armor, pitfalls, and checklist.
• Game simultaneous knockdown and double KO systems explained: trade KOs, round ties and reset rules Same-frame knockdown resolution — trade knockdown neutral reset vs priority-owned oki, double KO damage tiebreaks, grace windows, super and assist edge cases, Harbor Brawl ranked refactor, technique decision table vs priority-only trades, pitfalls, and checklist.
• Game power crush armor movement systems explained: advancing armor, crush highs and low punishes Midscreen gap-closer design — forward-moving one-hit super armor, crush-high hurtbox phases, low-profile punish windows, recovery launch risk, meter economy, Harbor Brawl power crush refactor, technique decision table vs stationary armor, pitfalls, and checklist.
• Game stun and dizzy systems explained: stun gauge, mash-out and round pressure Fighting-game stun design — stun gauge accumulation and proration, blockstun contribution, decay and neutral recovery, dizzy state and mash-out, throw stun interactions, Harbor Brawl stun refactor, technique decision table vs health-only rounds, pitfalls, and checklist.
• Game crossup and side-switch combat systems explained: ambiguous block direction, facing rules and corner carry Left-right mixup design — airborne and roll crossups, defender facing and block-direction rules, crossup protection, empty jumps and corner payoff, Harbor Brawl neutral refactor, technique decision table vs high/low-only mixups, pitfalls, and checklist.
• Game wall bounce systems explained: corner carry, wall splat and stage geometry combat Stage boundary combat design — elastic bounce, wall splat stick, corner carry, wall break meters, velocity retention math, juggle extensions, infinite prevention, Harbor Siege arena refactor, technique decision table vs flat knockback, pitfalls, and checklist.
• Game wall splat systems explained: stick states, follow-up windows and break meter integration Corner pin combat design — splat entry triggers, stick FSM duration, follow-up routing tiers, mash and meter escapes, wall-break meter coupling, Harbor Siege corner refactor, technique decision table vs bounce-only carry, pitfalls, and checklist.
• Game wall break systems explained: corner reset, damage scaling and stage geometry combat Terminal wall break design — fill-to-break meters, splat-to-break pipelines, midscreen reposition and mutual i-frames, break damage bonus and meter tax, Harbor Siege infinite-loop refactor, technique decision table vs uncapped wall carry, pitfalls, and checklist.
• Game hitstop and hit pause explained: freeze frames, impact feel and combat juice Impact feedback design — attacker vs defender freeze frames, scaling by weapon weight and damage tier, combo rhythm and cumulative caps, screen shake pairing, multiplayer authority, accessibility toggles, Harbor Ruins brawler refactor worked example, genre decision table, pitfalls, and checklist.
• Game aim assist explained: magnetism, friction zones, controller parity and fair PvP Shooter aim design — friction slowdown, rotation assist, bullet magnetism, target stickiness, distance curves, cross-play fairness, accessibility presets, Harbor Outpost twin-stick refactor worked example, technique decision table, pitfalls, and checklist.
• Game floating combat text and damage numbers explained: popups, color coding and readability Combat feedback UI — spawn positioning, typography and crit hierarchy, world vs screen space, overlap pooling and DoT merge, accessibility presets, multiplayer visibility, Harbor Ruins ARPG refactor worked example, genre decision table, pitfalls, and checklist.
• Game damage indicator and directional hit feedback systems explained: screen arcs, hit markers and audio cues Incoming damage orientation — compass ring wedges, vignette intensity caps, server-confirmed hit markers, HRTF gunfire and mono fallback, vertical chevrons, Harbor Crest 58→12% wrong-turn refactor, technique decision table vs full-screen flash, pitfalls, and checklist.
• Game HUD and heads-up display design explained: clarity, hierarchy and safe zones Persistent UI layer — information hierarchy, diegetic vs screen-space widgets, combat vs exploration modes, clutter budgets, minimap and objective placement, Harbor Ruins ARPG refactor, genre decision table, pitfalls, and checklist.
• Game juggle limit and decay systems explained: hit counters, forced stand and infinite prevention Anti-infinite juggle design — hard caps, hitstun and gravity decay curves, point budgets, forced stand and untechable gates, bounce budget coupling, Harbor Brawl juggle refactor, technique decision table vs scaling-only caps, pitfalls, and checklist.
• Game juggle and launch combo systems explained: air chains, hitstun scaling and reset rules Aerial combo design — launch tiers, juggle budgets, hitstun decay, bounces and OTG, tech escapes, damage scaling, Harbor Siege refactor, decision table vs knockback-only, pitfalls, and checklist.
• Game knockback systems explained: impulse, stagger, juggle and poise Combat displacement — velocity override vs impulse models, stagger and launch tiers, poise gates and weight classes, wall bounce and juggle decay, multiplayer validation, ledge friction, Harbor Ruins bridge boss refactor, genre decision table, pitfalls, and checklist.
• Game directional influence (DI) and knockback control explained: launch DI, SDI and combo escape Defender steering of knockback — launch vector rotation, per-frame smash DI during hitstun, survival vs combo DI, per-move scaling and caps, Harbor Brawl juggle escape refactor, technique decision table vs fixed knockback, pitfalls, and checklist.
• Game edge guard and ledgetrap systems explained: offstage pressure, recovery routes and stage KOs Vertical stage offense — edge guard vs ledgetrap vs gimp, recovery route taxonomy, ledge option tables and invulnerability, positioning and blast zones, Harbor Brawl offstage refactor, technique decision table vs ground oki only, pitfalls, and checklist.
• Game stagger and poise systems explained: posture meters, interrupts and super armor Interrupt resistance design — poise pools vs posture bars, guard break ripostes, super and hyper armor windows, weight class breakpoints, Harbor Ruins frost knight refactor, technique decision table, pitfalls, and checklist.
• Game crowd control systems explained: stuns, roots, DR and cleanse Hard vs soft CC taxonomy, application pipeline and armor gates, diminishing returns tracks, cleanse and tenacity, knockup and fear steering, boss immunity phases, Harbor Ruins frost mage refactor, technique decision table vs poise-only, pitfalls, and checklist.
• Game damage mitigation systems explained: armor, resist and DR layers Flat vs percent armor, resistance caps, stacking order pipeline, penetration and bypass rules, temporary DR cooldowns, Harbor Ruins tank refactor, technique decision table vs shields-only, pitfalls, and checklist.
• Game turn order and initiative systems explained: speed stats, ATB gauges and action queues Turn scheduling design — fixed party order, speed initiative, CT/ATB gauges, timeline inserts, delay and haste skills, surprise rounds, Harbor Chronicles boss refactor, technique decision table, pitfalls, and checklist.
• Game camera shake and screen shake explained: trauma, decay and impact feel Impact feedback design — trauma and decay models, procedural noise vs authored curves, directional punch, hitstop and haptics pairing, accessibility presets, Harbor Ruins boss calm-window refactor, genre decision table, pitfalls, and checklist.
• Game threat and aggro systems explained: hate tables, taunts and tank targeting Co-op targeting design — threat generation from damage and heals, taunt overrides and tank swaps, decay and wipe rules, add management, server authority, Harbor Ruins Sunken Archivist raid refactor, aggro model decision table, pitfalls, and checklist.
• Game projectile systems explained: ballistics, collision, pooling and netcode Engine layer under gunplay — hitscan vs kinematic bullets, trajectory integration and gravity, sweep collision against tunneling, pierce and bounce rules, object pooling and per-owner caps, lag compensation rewind, Harbor Outpost twin-stick horde refactor, technique decision table, pitfalls, and checklist.
• Game area of effect (AoE) systems explained: shapes, falloff and fair telegraphs Circle, cone, line, ring and chain geometry — overlap queries vs sweeps, damage falloff and friendly-fire policy, telegraph windups and safe zones, spatial indexing, Harbor Ruins archmage refactor, technique decision table vs projectiles and single-target, pitfalls, and checklist.
• Game lock-on and targeting systems explained: acquisition, camera orbit and target priority Action combat targeting — forward acquisition cones and scored ranking, soft vs hard lock, camera orbit and strafe assist, target switching with hysteresis, weak points and cleave rules, multiplayer authority, Harbor Ruins ARPG refactor, technique decision table, pitfalls, and checklist.
• Game hitbox and hurtbox systems explained: collision volumes, layers and combat detection Combat collision design — attack volumes vs defender volumes, sweep tests and animated shapes, collision layers and masks, weak-point multipliers, i-frame suppression, multiplayer authority, Harbor Ruins melee refactor, technique decision table, pitfalls, and checklist.
• Game grenade and throwable systems explained: arc preview, fuse timing and blast radius Tactical throwables — throw arc preview and charge curves, fuse and cook timing, blast falloff and line-of-sight occlusion, bounce and sticky behaviors, frag/flash/smoke/molotov roles, friendly fire rules, Harbor Ruins breach refactor, technique decision table, pitfalls, and checklist.
• Game grenade utility lineup practice systems explained: pin markers, ghost trajectories and patch-drift detection Reproducible throw recipes — server pin registry, ghost trajectory replay, cook-offset calibration, smoke/molly/flash lineup libraries, CI patch-drift detection, Harbor Siege 47→11% failed-execute refactor, decision table vs YouTube-only guides, pitfalls, and checklist.
• Game HE grenade and high-explosive blast damage systems explained: radial falloff, armor interaction and wallbang coupling Damage utility design — server detonation FSM, quadratic falloff curves, line-of-sight occlusion, penetration budgeting, armor and helmet modifiers, tag and audio telegraphs, Harbor Breach 58→14% unfair nade death refactor, technique decision table vs flat radius, pitfalls, and checklist.
• Game flash, stun and blind systems explained: vision impairment, tinnitus and counterplay Flashbang utility design — line-of-sight exposure curves, facing-angle falloff, peak whiteout and afterimage duration, tinnitus audio muffling, self and ally flash policy, Harbor Strike 63→17% unfair flash death refactor, technique decision table, pitfalls, and checklist.
• Game decoy grenade and fake footstep audio deception systems explained: phantom movement, information warfare and counterplay Misdirection utility design — server phantom emitters, surface-matched gait libraries, shared propagation graph, per-team concurrent caps, ranked information tiers, Harbor Echo 57→13% false-rotate refactor, decision table vs real-player audio only, pitfalls, and checklist.
• Game smoke grenade and screen vision systems explained: occlusion, dissipation and one-way smoke Vision-denial utility — volumetric occlusion, line-of-sight blocking, dissipation timers, one-way smoke fairness, nameplate policy, flash interaction, Harbor Depot 58→19% smoke-stall refactor, technique decision table, pitfalls, and checklist.
• Game incendiary and molotov fire zone systems explained: burn pools, spread and area denial Damage-denial utility — fuel pool footprints, burn tick telegraphs, spread caps, smoke extinguish counterplay, friendly fire policy, Harbor Market 71→24% site-camp refactor, technique decision table, pitfalls, and checklist.
• Game hit registration and lag compensation systems explained: server rewind, hitscan validation and fair trades Shooter netcode fairness — server authority, lag compensation rewind, hitscan vs projectile paths, peeker’s advantage, trade resolution, Harbor Ridge 67% ticket reduction refactor, technique decision table, pitfalls, and checklist.
• Game bullet tracer visual ballistics feedback systems explained: server-synced paths, readability and competitive fairness Gunfight readability — server tracer emission, hitscan vs projectile sync, team color policy, smoke and wallbang occlusion, bandwidth caps, Harbor Vector 51→12% crossfire-confusion refactor, decision table vs cosmetic-only VFX, pitfalls, and checklist.
• Game overtime and sudden death systems explained: match extension, tiebreakers and fair endings Competitive tie resolution — overtime FSMs, sudden death vs golden goal, multi-OT escalation ladders, mode-specific deciders for zone capture and bomb objectives, Harbor Arena 18→7 min OT refactor, technique decision table, pitfalls, and checklist.
• Game side swap and halftime balance systems explained: asymmetric maps, fairness and competitive parity Ranked fairness for attack/defend modes — halftime FSM, economy reset vs carry-over, side win-rate telemetry, overtime side-pick rules, series-level swaps, Harbor Arena 58→47% skew refactor, technique decision table, pitfalls, and checklist.
• Game pick-ban and map veto systems explained: draft phases, competitive pools and fair series setup Pre-match map draft for ranked and esports — ban/pick FSMs, pool rotation, series deciders, captain timers and disconnect policy, Harbor Arena 63→18% repeat-map churn refactor, technique decision table vs random select, pitfalls, and checklist.
• Game match lobby and pregame systems explained: ready checks, party merge and countdown FSM Structured pregame between queue and round one — accept gates, roster lock, map veto hooks, loadout lock timing, AFK backfill, server countdown, Harbor Arena 41→9% abandon refactor, decision table vs instant start, pitfalls, and checklist.
• Game warmup and practice range systems explained: pre-match drills, shooting lanes and muscle-memory onboarding Bounded server warmup between lobby and freeze — static and moving bot lanes, recoil walls, utility sandboxes, ranked time caps, Harbor Arena 58→12% cold-start round-loss refactor, decision table vs instant start, pitfalls, and checklist.
• Game AFK and leaver penalty systems explained: detection, escalation and fair enforcement Idle input heuristics, dodge vs leave classification, tiered LP and MMR penalties, reconnect grace integration, loss shields for teammates, Harbor Ridge 38→9% unfair-loss churn refactor, decision table vs instant ban, pitfalls, and checklist.
• Game surrender and forfeit vote systems explained: thresholds, cooldowns and fair exit paths Vote FSM, timing gates, supermajority thresholds, remake vs surrender separation, ranked LP policy, round-boundary resolution, Harbor Arena 52→14% trapped-match churn refactor, decision table vs forced play, pitfalls, and checklist.
• Game reconnect and disconnect recovery systems explained: grace windows, state snapshots and mid-match rejoin Presence FSM and heartbeat tuning, tiered grace timers, signed rejoin tokens, authoritative snapshot catch-up, bot backfill vs team shrinkage, Harbor Ridge 52→11% session abandon refactor, decision table vs instant kick, pitfalls, and checklist.
• Game network quality, packet loss and jitter adaptation systems explained: measurement tiers, adaptive interpolation and honest HUD Gameplay-channel RTT/jitter/loss sampling, quality FSM with hysteresis, per-tier mitigation profiles, input redundancy and reliable events, Harbor Apex 48→9% rubber-band complaint refactor, decision table vs ping-only UI, pitfalls, and checklist.
• Game client-side prediction and server reconciliation systems explained: responsive movement without desync Input command buffers, local movement prediction, authoritative tick rewind, error-correction blending, remote-player interpolation, Harbor Ridge 47→9% rubber-band refactor, decision table vs delay-only netcode, pitfalls, and checklist.
• Game remote entity interpolation and snapshot smoothing systems explained: jitter buffers, render delay and bandwidth Netcode display layer — snapshot ring buffers, render delay and adaptive jitter margin, position lerp and quaternion slerp, dead-reckoning caps, animation velocity sync, Harbor Vanguard 58→11% skating refactor, decision table vs instant snap, pitfalls, and checklist.
• Game server region selection and data center routing systems explained: latency probes, party constraints and fair match placement Discovery vs selection vs placement — UDP probes on gameplay ports, p95 RTT caps, preferred region locks, party max-ping rules, cross-region fallback rings, Harbor Meridian 52→11% high-ping misroute refactor, decision table vs geo-DNS-only, pitfalls, and checklist.
• Game server tick rate and update rate networking systems explained: simulation Hz, snapshot cadence and competitive fairness Authoritative clock design — simulation Hz vs network snapshot rate vs render FPS, 64 vs 128 tick tradeoffs, sub-tick hit sampling, input buffering, Harbor Crest 47→9% unfair-trade refactor, decision table vs rollback-only, pitfalls, and checklist.
• Game frame data explained: startup, active, recovery and frame advantage Combat timing contract — startup/active/recovery phases, hitstun and blockstun, plus and minus frames, input buffers and cancel windows, hitstop interaction, multiplayer rollback, Harbor Ruins bridge boss refactor, technique decision table, pitfalls, and checklist.
• Game hitstun and blockstun systems explained: stun states, frame advantage and combo scaling Post-connect timing design — hitstun vs blockstun state machines, frame advantage math, stun decay in combos, airborne vs grounded stun, block pushback curves, Harbor Brawl pressure refactor, technique decision table vs damage-only tuning, pitfalls, and checklist.
• Game pushback and hurtbox displacement systems explained: spacing geometry, corner traps and stage control Fighting-game spacing design — hit vs block pushback, attacker recoil, per-frame displacement curves, corner clamp and redirect rules, combo drift scalers, Harbor Brawl gap-at-stun-end refactor, technique decision table vs frame-data-only tuning, pitfalls, and checklist.
• Game blockstring and pressure systems explained: frame chains, pushback and tick throws Block pressure design — true blockstrings vs frame traps, plus-on-block chains, pushback curves and corner geometry, reset points and shimmies, tick throw windows, Harbor Brawl pressure refactor, technique decision table vs damage-only strings, pitfalls, and checklist.
• Game whiff punish and recovery frame systems explained: spacing, bait and counterplay Neutral punish design — startup/active/recovery taxonomy, punish tiers at spacing bands, hurtbox extension on whiff, counter-hit vs whiff windows, sweep recovery risk, Harbor Brawl neutral refactor, technique decision table vs damage-only movelists, pitfalls, and checklist.
• Game whiff cancel and recovery escape systems explained: miss recovery, risk budgets and neutral safety Miss-only recovery cancels — whiff vs hit-confirm routing, cancel window placement, destination whitelists, spacing gates and resource costs, Harbor Brawl sweep refactor, technique decision table vs long recovery only, pitfalls, and checklist.
• Game hit confirm systems explained: link windows, cancel routes and safe pressure Combo confirm design — single-hit and delayed confirms, target combos vs manual links, frame slack and input buffer, blockstring staggers, rekka gating, Harbor Brawl confirm refactor, technique decision table vs always-on chains, pitfalls, and checklist.
• Game link, chain and target combo systems explained: gatlings, frame links and auto sequences Combo routing design — frame advantage links, magic series gatlings, input-gated target combos, scaling interaction, Harbor Siege combo clarity refactor, technique decision table vs cancel-only routing, pitfalls, and checklist.
• Game just-frame timing systems explained: one-frame links, electric motions and reward scaling Execution-tier design — tight link windows, electric-style motion bonuses, standard vs JF vs perfect tiers, buffer and rollback pairing, training overlay feedback, Harbor Brawl link refactor, technique decision table vs buffered chains, pitfalls, and checklist.
• Game special cancel systems explained: cancel windows, route gating and combo extensions Fighting-game cancel design — normal-to-special and super cancels, jump cancel routes, cancel tables and contact gating, buffer priority, Harbor Brawl cancel refactor, technique decision table vs target combos, pitfalls, and checklist.
• Game super cancel systems explained: meter routes, damage scaling and confirm design Super meter offense design — normal and special into super routes, L1/L2/L3 cost tiers, hit-only gating, super-cancel scaling penalties, hit-confirm coupling, Harbor Siege refactor, technique decision table vs special-cancel-only, pitfalls, and checklist.
• Game rekka attack systems explained: multi-stage specials, gating and route design Multi-stage special sequences — per-stage hit and block gating, branching routes, recovery tiers, input buffer windows, Harbor Brawl rekka refactor, technique decision table vs target combos and special cancels, pitfalls, and checklist.
• Game divekick attack systems explained: trajectories, mixups and anti-air counterplay Rushdown aerial offense — diagonal descent trajectories, variable height via tiger knee, low-profile hurtbox, crossup angles, landing recovery risk, Harbor Brawl rushdown refactor, technique decision table vs jump-in-only offense, pitfalls, and checklist.
• Game jump arc and gravity systems explained: apex height, fast fall and aerial physics Foundational aerial movement — jump squat, gravity constants, short-hop multipliers, fast-fall acceleration, juggle gravity scaling, air control curves, Harbor Brawl neutral refactor, technique decision table vs flat jump speed, pitfalls, and checklist.
• Game gravity inversion and flip traversal systems explained: zone flips, momentum carry and ceiling walk Dual-orientation platforming — global vs zone gravity flips, velocity basis transforms, flip pads and cooldowns, camera reorientation, collision layer swaps, Harbor Observatory 34→78% refactor, technique decision table vs wall-jump and rotating rooms, pitfalls, and checklist.
• Game ledge hang and shimmy systems explained: grab windows, stamina timers and cliff recovery Suspended ledge traversal — lip detection probes, hang FSM states, lateral shimmy bounds, stamina slip-off, climb-up mantle handoff, Harbor Spire 71→14% fall-death refactor, technique decision table vs wall-jump and ladders, pitfalls, and checklist.
• Game wall slide movement systems explained: controlled descent, friction caps and kickoff transitions Vertical shaft traversal — adhesion probes, capped slide speed, stamina timers, kickoff to wall-jump or neutral drop, Harbor Spire descent 58→11% fall-death refactor, technique decision table vs wall-run and ledge hang, pitfalls, and checklist.
• Game ceiling cling and crawl traversal systems explained: inverted attachment, crawl FSM and drop transitions Upside-down tunnel traversal — attachment probes, local cling vs global flip, inverted input mapping, stamina slip-off, upright camera readability, Harbor Catacombs 47→82% clear-rate refactor, technique decision table vs wall-slide and gravity inversion, pitfalls, and checklist.
• Game tightrope and balance beam narrow path traversal systems explained: sway physics, fall recovery and precision movement Rope-bridge and rafter crossings — foot-probe collision, geometry-only vs sway-meter FSM, counter-input stabilization, wind gust telegraphs, slip grab recovery, Harbor Bridge 63→19% fall-death refactor, technique decision table vs mantling and ledge hang, pitfalls, and checklist.
• Game glider and paraglider aerial descent systems explained: lift, stall speed and landing design Summit-to-valley descents — arcade float vs lift-physics glide, deploy FSM and coyote deploy, lift-drag sink curves, thermal updrafts, auto-flare landing pads, Harbor Cliffs 71→18% fall-death refactor, technique decision table vs zipline and grapple, pitfalls, and checklist.
• Game surface grind and rail slide traversal systems explained: mount windows, spline speed and chain transfers Rooftop and skate routes — spline vs ledge grinds, mount FSM and coyote land, speed clamps on curves, gap transfer magnets, Harbor Rail District 71→14% fall-off refactor, technique decision table vs wall-run and zipline, pitfalls, and checklist.
• Game rope swing, vine and pendulum traversal systems explained: grab timing, arc physics and chain momentum Jungle and gorge crossings — scripted arc vs physics pendulum, grab FSM and coyote attach, release velocity and chain momentum, Harbor Canopy 64→12% miss-rate refactor, technique decision table vs grapple and zipline, pitfalls, and checklist.
• Game slope, friction and ice surface movement systems explained: slippery ground, hill physics and control feel Ground movement physics — friction coefficients, slope gravity projection, ice slide momentum, counter-brake windows, Harbor Peaks glacier 29→73% refactor, technique decision table vs conveyors and wind zones, pitfalls, and checklist.
• Game anti-air systems explained: jump arcs, AA hitboxes and air-to-ground defense Air-to-ground defense — jump arc phases, grounded AA normals vs invincible reversals, air-to-air trades, projectile AA layers, crossup and empty-jump conditioning, Harbor Brawl neutral refactor, technique decision table vs zoning-only, pitfalls, and checklist.
• Game air-to-air combat systems explained: jump neutral, trade priority and aerial reset routes Mutual airborne fights — jump arc phases, height-band hitboxes, aerial trade priority and class rules, air reset vs full launch gating, double-jump air wars, Harbor Brawl aerial refactor, technique decision table vs ground-only AA, pitfalls, and checklist.
• Game launcher attack systems explained: juggle entry, float states and combo routes Combo route openers — vertical and diagonal launch, sweep float and bounce entry, juggle-entry FSM, counter-hit launch bonus, Harbor Brawl combo refactor, technique decision table vs ground-only confirms, pitfalls, and checklist.
• Game shimmy and walk-throw pressure systems explained: spacing bait, throw mixups and reset points Neutral pressure design — walk-back bait spacing, throw proximity windows, tick throws vs shimmy resets, defender conditioning loops, Harbor Brawl refactor, technique decision table vs frame-trap-only pressure, pitfalls, and checklist.
• Game unblockable attack systems explained: overheads, armor moves and anti-block design Anti-block mixup layer — height mismatch vs ignore_block flags, overhead and low unblockables, command grabs vs strike unblockables, armor and invincible reversals, Harbor Brawl mixup refactor, technique decision table vs guard-break-only, pitfalls, and checklist.
• Game trade clash and attack priority systems explained: neutral trades, clash boxes and simultaneous hits Footsies collision design — trade windows, priority tiers, clash boxes vs hurtboxes, symmetric and asymmetric trade damage, rollback determinism, Harbor Brawl neutral refactor, technique decision table vs first-hit-wins collision, pitfalls, and checklist.
• Game super armor and hyper armor systems explained: hit tolerance, armor break and through-pressure design Through-attack design — single-hit vs multi-hit super armor, hyper armor and damage thresholds, throw and armor-break counterplay, chip on block, Harbor Brawl grappler refactor, technique decision table vs invincibility-only defense, pitfalls, and checklist.
• Game okizeme, meaties and frame trap systems explained: knockdown pressure, wake-up timing and string bait Knockdown offense design — oki setup taxonomy, meaty active-frame timing, frame trap strings, safe jumps and fuzzy guard, Harbor Brawl wake-up refactor, technique decision table vs damage-only knockdown tuning, pitfalls, and checklist.
• Game vortex and knockdown setup systems explained: repeatable mixups, layered oki and loop prevention Knockdown loop design — vortex taxonomy, layered mixup trees, safe jump re-entries, escape routes and scaling caps, Harbor Brawl grappler refactor, technique decision table vs one-shot okizeme, pitfalls, and checklist.
• Fighting game input notation explained: numpad, motion inputs and command readers Shared fighting-game command language — numpad 1–9 directions, QCF/QCB/DP/half-circle/charge motions, button labels, diagonal leniency and SOCD cleaning, command-reader implementation, Harbor Brawl refactor, technique decision table vs context actions, pitfalls, and checklist.
• Game assist mode and modern controls explained: simplified inputs, accessibility and competitive integrity Input simplification design — one-button specials, auto-combo tiers, classic vs modern control layers, ranked queue separation, charge/back helpers, Harbor Brawl onboarding refactor, technique decision table vs motion-only design, pitfalls, and checklist.
• Game zoning and space control combat systems explained: neutral, footsies and projectile layers Fighting-game neutral design — distance bands, poke ranges, projectile layering, archetype matchups, breaking zoning, Harbor Brawl spacing refactor, technique decision table vs rushdown-only rosters, pitfalls, and checklist.
• Game burst and alpha counter defense systems explained: combo breaks, guard cancels and defensive meter Defensive reset design — combo-break bursts, blue vs gold burst modes, guard-cancel alpha counters, burst meter economy and regeneration, bait strings and whiff recovery, Harbor Brawl defensive refactor, technique decision table vs block-only defense, pitfalls, and checklist.
• Game corner carry systems explained: pushback routing, wall proximity and spatial pressure Fighting-game spatial pressure design — pushback on block, knockback vectors, side-switch and throw repositioning, carry budgets and wall-proximity multipliers, Harbor Brawl midscreen-to-wall refactor, technique decision table vs damage-only pressure, pitfalls, and checklist.
• Game corner escape and pressure systems explained: trap routes, reversals and stage geometry Corner trap and escape design — stage geometry, carry and oki layers, backdash and roll routes, reversal and burst escapes, Harbor Brawl corner refactor, technique decision table vs midscreen-only pressure, pitfalls, and checklist.
• Game dash and run cancel systems explained: movement cancels, gap closers and recovery routes Movement expressiveness — forward dash vs run archetypes, block-to-run and attack-to-dash cancels, dash-to-block recovery, backdash invincibility, Harbor Brawl rushdown refactor, technique decision table vs walk-only spacing, pitfalls, and checklist.
• Game wavedash movement systems explained: air-to-ground slides, spacing and momentum Momentum conversion movement — air-dodge and brake-cancel landing slides, crouch-cancel run wavedashes, friction and slope physics, spacing retreat and approach, Harbor Brawl Anchor refactor, technique decision table vs dash and drive rush, pitfalls, and checklist.
• Game drive rush movement systems explained: gap closers, cancel routes and meter economy Offensive approach design — drive rush into attack vs block, cancel windows and frame advantage bonuses, gauge cost and burnout, projectile interaction rules, Harbor Brawl rush refactor, technique decision table vs plain dash, pitfalls, and checklist.
• Game drive impact systems explained: armored normals, wall splat routes and gauge tradeoffs Armored payoff design — startup armor tiers, wall splat and crumple routes, drive gauge costs, interactions with hold parry and throws, Harbor Siege refactor, technique decision table vs plain crush counters, pitfalls, and checklist.
• Game rushdown pressure systems explained: gap closers, corner traps and mixup density Close-range pressure design — tiered gap closers, plus-on-block approach, blockstring reset points, corner carry routes, conditioning loops, Harbor Brawl refactor, technique decision table vs zoning-only or damage-only tuning, pitfalls, and checklist.
• Game projectile clash systems explained: priority tiers, mutual destruction and neutral wars Fighting-game projectile interaction — mutual destroy vs priority win, durability and super-projectile flags, beam vs ballistics, clash resolution order, Harbor Brawl fireball refactor, technique decision table vs reflect-only defense, pitfalls, and checklist.
• Game homing attack systems explained: steering, lock-on and tracking projectile design Tracking projectile design — seek steering and turn-rate caps, delayed homing and snapshot lock-on supers, airborne tracking rules, anti-air escape windows, Harbor Brawl missile refactor, technique decision table vs straight-line projectiles, pitfalls, and checklist.
• Game motion input and special move systems explained: command notation, lenience and conflict resolution Special move parsing — numpad notation, input history scrub windows, diagonal leniency and SOCD cleaning, negative edge and shortcuts, charge-back partition, motion priority tables, Harbor Brawl input refactor, technique decision table vs buffer-only leniency, pitfalls, and checklist.
• Game input buffering explained: pre-input queues, coyote time and responsive combat Input leniency design — pre-input action queues, per-action buffer windows, coyote time and jump grace, parry leniency, cancel chains, rollback determinism, Harbor Ruins bridge boss refactor, technique decision table vs frame data, pitfalls, and checklist.
• Game plink and input priority systems explained: 1-frame links, simultaneous inputs and lenient combos Priority linking design — plink windows, strength and motion priority tables, 1-frame link enablement without hitstun buffs, SOCD and diagonal cleaning, rollback determinism, Harbor Brawl combo refactor, technique decision table vs buffer-only leniency, pitfalls, and checklist.
• Game animation cancellation systems explained: cancel windows, chains and priority rules Combat expressiveness — recovery vs startup vs hit-confirm cancels, cancel graphs and priority tiers, movement and resource cancels, Harbor Siege melee refactor, technique decision table vs input buffering alone, pitfalls, and checklist.
• Game one-way platform and drop-through systems explained: soft collision, layer masks and vertical level design Platformer vertical routing — pass-through from below, down+jump drop-through, collision layer masks and ignore windows, moving-platform parenting, Harbor Peaks optional-path refactor, technique decision table vs solid tiles, pitfalls, and checklist.
• Game coyote time and jump grace leniency explained: post-ledge windows, jump buffers and platformer feel Platformer input leniency — coyote time after ledge exit, jump buffer before landing, ground-probe coupling, genre tuning bands, Harbor Peaks edge-jump refactor, technique decision table vs frame-perfect jumps, pitfalls, and checklist.
• Game variable jump height and hold-release jump cut systems explained: apex control, minimum hops and platformer precision Platformer vertical control — gravity cut on release, impulse scaling and apex hold models, min/mid/max hop bands, fast-fall coupling, Harbor Ascent Wind Shrine shaft refactor, technique decision table vs binary jumps, pitfalls, and checklist.
• Game bounce pad, spring and trampoline systems explained: launch impulses, chain rules and platformer verticality Vertical launch surfaces — velocity-set vs impulse-add models, directional springs, pogo chain and lockout rules, jump-hold coupling, Harbor Ascent Crystal Spire shaft refactor, technique decision table vs manual jumps, pitfalls, and checklist.
• Game moving platform and elevator systems explained: velocity inheritance, parenting and crush hazards Kinematic path motion and rider parenting — delta vs transform attach, jump-off and walk-off velocity carry, phase-synced elevator chains, one-way and crush coupling, Harbor Foundry shaft refactor, technique decision table vs static tiles, pitfalls, and checklist.
• Game rotating platform and turntable systems explained: angular velocity, rim carry and alignment puzzles Tangential rim velocity and delta rotation on riders — centrifugal slip thresholds, gap-alignment and gear-chain puzzles, networked angle determinism, Harbor Clocktower 27→76% refactor, technique decision table vs linear movers, pitfalls, and checklist.
• Game conveyor belt and moving walkway systems explained: surface velocity, friction coupling and factory puzzles Tangential surface velocity fields — input-relative effective speed, entry ramps and edge exit carry, reversible and vertical belts, hazard phase sync, Harbor Assembly sorting floor refactor, technique decision table vs moving platforms, pitfalls, and checklist.
• Game wind zone and updraft traversal systems explained: force fields, air control and vertical puzzles Volume acceleration fields — constant vs gradient updrafts, terminal rise caps, gust phase telegraphs, airborne coupling with jump arcs and air dashes, downdraft hazards, Harbor Peaks wind shrine refactor, technique decision table vs conveyors and bounce pads, pitfalls, and checklist.
• Game mantling and vaulting systems explained: ledge grab, height rules and traversal feel Vertical traversal assist — ledge detection probes, height bands, mantle vs vault selection, root motion vs procedural snap, hang states, Harbor Ruins cliff refactor, technique decision table vs parkour and platformers, pitfalls, and checklist.
• Game grapple hook and rope swing traversal systems explained: anchors, momentum and arc design Grapple aim validation, tether constraints and pendulum physics, swing vs pull-to modes, momentum carry on release, Harbor Ruins canyon refactor, technique decision table vs mantling and parkour, pitfalls, and checklist.
• Game cover systems explained: snap, peek, blind fire and AI tactics Shooter cover design — hard vs soft cover, snap and lean mechanics, cover-to-cover traversal, blind fire, destructible props, third-person vs first-person feel, enemy AI cover usage, multiplayer fairness, genre table, and a production checklist.
• Game destructible environments explained: fracturing, debris, cover and performance Level destruction design — pre-baked vs runtime fracturing, voxel and mesh shatter pipelines, debris pooling, cover and navmesh updates, multiplayer authority, performance budgets, genre patterns, and a production checklist.
• Game checkpoints and respawn systems explained: bonfires, world state and death loops Death and retry design — checkpoint trigger types, respawn world-state rules, enemy and loot persistence, bonfire UX, roguelike run resets, co-op authority, snapshot implementation, genre table, and a production checklist.
• Game death penalty systems explained: souls currency, XP debt, durability and fair consequence Failure cost design — recoverable stain currency, permanent XP loss, durability and repair tax, run resets, equipment drops, PvP loot risk, banking and at-risk meters, Harbor Sanctum refactor, technique decision table vs checkpoints and economy, pitfalls, and checklist.
• Game spawn protection and respawn timer systems explained: invulnerability, spawn selection and anti-camp design Fair re-entry after death — invulnerability windows and cancel rules, furthest-enemy spawn scoring, LOS penalties, streak-based timer escalation, safe-zone shells, Harbor Outpost 67→14% spawn-kill refactor, decision table vs instant respawn, pitfalls, and checklist.
• Game minimap and tactical radar UI systems explained: rotation, fog of war and competitive awareness Tactical shooter radar design — player-facing rotation vs north-up, zoom tiers, teammate facing wedges, server gunfire and footstep blips, bomb-site overlays, ranked integrity rules, Harbor Vanguard 61→16% flank-surprise refactor, decision table vs ping-only, pitfalls, and checklist.
• Game gunfire audio propagation PvP systems explained: distance falloff, occlusion and directional awareness Competitive gunfire information — server gunfire event bus, per-weapon attenuation curves, occlusion zones, suppressor profiles, hearability_score for audio and minimap blips, Harbor Echo 58→13% silent-flank refactor, decision table vs flat SFX, pitfalls, and checklist.
• Game scoreboard and tab stats display systems explained: team tables, round context and economy columns Hold-tab overlay FSM — mirrored team columns, K/D/A and objective scoring, round vs match toggle, economy and ping columns, alive-status rows, Harbor Arena 63→19% macro-blindness refactor, decision table vs kill-feed-only, pitfalls, and checklist.
• Game kill cam and death camera systems explained: replay POV, fairness and skip UX Post-death camera FSM — killer POV vs chase cam, server rewind replay, FOV and ADS matching, duration and skip rules, ranked disclosure, Harbor Crest 64→13% unfair-death churn refactor, decision table vs recap-only, pitfalls, and checklist.
• Game spectator mode systems explained: death cam handoff, information policy and esports broadcast Post-death spectator FSM — follow teammate vs free cam, ranked fog-of-war policy, broadcast delay and observer presets, clutch voice rules, Harbor Arena 58→12% ghosting churn refactor, decision table vs kill-cam-only, pitfalls, and checklist.
• Game kill feed and death recap systems explained: attribution, assist credit and fair information Multiplayer combat log UX — feed row anatomy, weapon and headshot icons, assist thresholds, death recap panels, kill cam policy, streamer anonymization, Harbor Outpost 71→18% confusion refactor, decision table vs scoreboard-only, pitfalls, and checklist.
• Game trade frag and teammate revenge elimination systems explained: revenge windows, proximity credit and team duel fairness Server revenge ledger — trade window FSM, proximity and LOS gates, trade vs refrag vs anti-trade credit, kill feed badges, MVP weighting, Harbor Ridge 61→11% double-death frustration refactor, decision table vs raw K/D, pitfalls, and checklist.
• Game round MVP and performance rating systems explained: weighted scoring, attribution and fair recognition Server-authoritative round_score — kill and assist weights, trade and clutch bonuses, objective and utility credit, MVP tie-breaks, end-of-round card UX, Harbor Vanguard 57→14% recognition-dispute refactor, decision table vs raw K/D, pitfalls, and checklist.
• Game clutch situation and last-player-standing systems explained: 1vX detection, presentation and fair tension Server clutch FSM — structural vs contextual 1vX, depth counter, context gates and hysteresis, spectator auto-cam, graduated MVP multipliers, SAVE round tags, Harbor Crest 52→11% clutch-quit refactor, decision table vs boolean hype, pitfalls, and checklist.
• Game weapon death drop and pickup systems explained: ground loot, ammo inheritance and economy coupling Tactical shooter ground loot — server drop FSM, spawn offset validation, pickup eligibility, mag and reserve inheritance, atomic swap-and-drop, despawn TTL, eco pickup caps, Harbor Rift 49→9% loot-dispute refactor, decision table vs buy-only, pitfalls, and checklist.
• Game revive and downed systems explained: bleedout, channel rez and squad wipes Downed vs dead taxonomy, bleedout timers and shared pools, channel and drag-to-safety interactions, rez sickness and medic charges, squad wipe policy, Harbor Siege medic refactor, technique decision table vs checkpoints-only, pitfalls, and checklist.
• Game environmental hazard systems explained: lava, poison zones and fair world damage Hazard taxonomy (DoT, burst, instant kill, fall/crush), tick pipelines and mitigation gates, telegraph standards, resistance and equipment affordances, Harbor Ruins volcanic refactor, technique decision table vs enemy-only damage, pitfalls, and checklist.
• Game fall damage and landing systems explained: height tracking, impact formulas and roll mitigation Fall policy taxonomy (none, scaled, lethal, mitigation-gated), peak altitude and impact velocity tracking, damage curves and safe bands, roll landing and soft zones, death integration, Harbor Ruins cliff refactor, technique decision table vs hazard-only damage, pitfalls, and checklist.
• Game ground pound and dive stomp systems explained: shockwaves, breakables and aerial finishers Crystal gallery vertical breaks — airborne activation FSM and coyote stomp, minimum fall-height gate, velocity-scaled shockwave radius, weak-point colliders, committed-impact i-frames, Harbor Caverns 62→88% break-success refactor, technique decision table vs fall damage and bounce pads, pitfalls, and checklist.
• Game friendly fire systems explained: team damage rules, AoE collateral and fair PvE FF policy taxonomy (off, scaled, source-split, role carve-outs), damage pipeline filters, grenade and DoT collateral, knockback and rez edge cases, kill-feed attribution, Harbor Siege medic refactor, technique decision table vs FF-off-only, pitfalls, and checklist.
• Game teammate silhouette and outline visibility systems explained: ally x-ray, occlusion rules and fair team awareness Ally visibility taxonomy — edge outline vs interior fill, occlusion and distance falloff, smoke and flash suppression, colorblind presets, ranked integrity, Harbor Vanguard 47→9% FF confusion refactor, decision table vs nameplate-only, pitfalls, and checklist.
• Game party composition and role design explained: tank-healer-DPS, flex slots and encounter tuning Role taxonomy beyond the trinity, composition models by genre, encounter-driven comp gates, flex and hybrid builds, PvE vs PvP tuning, Harbor Siege Bastion of Ash refactor, technique decision table vs DPS-only stacking, pitfalls, and checklist.
• Game party character switch systems explained: hot-swap, bench roster and tag-team combat Switch mode taxonomy — real-time hot-swap, tag-team assist, turn-based bench, co-op body-swap and permadeath rotation; state carry-over for HP, buffs and cooldowns, swap i-frames and cooldown tuning, AI handoff, Harbor Chronicles refactor, technique decision table vs single-character combat, pitfalls, and checklist.
• Game loot distribution systems explained: personal loot, need/greed rolls and party fairness Distribution mode taxonomy (FFA, round robin, master looter, need/greed, personal loot), roll eligibility and bind rules, pity and role bonuses, Harbor Siege Vault of Tides refactor, technique decision table vs free-for-all, pitfalls, and checklist.
• Game character customization explained: sliders, presets, armor and identity Avatar and build identity — morph sliders vs presets, modular armor and dye channels, transmog, unlock pacing, bone scaling and netcode sync, silhouette readability in PvP, monetization ethics, genre table, and a production checklist.
• Game character respec systems explained: build reset, cost models and downstream effects Talent and stat refund design — full vs partial reset taxonomy, currency and cooldown cost models, gear and quest reconciliation, PvP build locks, Harbor Ruins refactor, technique decision table vs no-respec, pitfalls, and checklist.
• Game New Game Plus systems explained: carry-over rules, scaling and replay loops NG+ replay design — carry-over taxonomy, cycle architecture, enemy and reward scaling, narrative branches and scene skip, co-op normalization, Harbor Chronicles refactor, technique decision table vs roguelite DLC, pitfalls, and checklist.
• Game escort mission systems explained: follow AI, failure states and co-op pacing Escort mission design — follow/lead/convoy taxonomy, tether and catch-up AI, threat routing, graded failure states, co-op squad anchoring, Harbor Siege convoy refactor, technique decision table vs fetch quests, pitfalls, and checklist.
• Game enemy vision cone and line of sight systems explained: FOV, occlusion and alert states Stealth sight detection — FOV geometry, peripheral vs central sight, multi-sample LOS raycasts, distance and lighting modifiers, alert state machines, Harbor Siege infiltration refactor, technique decision table vs trigger volumes, pitfalls, and checklist.
• Game quick time event systems explained: prompt windows, failure branches and cinematic control QTE design — single-button, mash, sequence and analog prompt taxonomy, input buffers and animation sync, failure and skip policy, accessibility, Harbor Chronicles boss refactor, technique decision table vs finishers and skill checks, pitfalls, and checklist.
• Game stat scaling and diminishing returns explained: curves, soft caps and build diversity RPG stat math — linear, exponential and logistic scaling taxonomy, additive vs multiplicative stacking, soft and hard caps, rating-to-percent conversion, Harbor Ruins combat refactor, technique decision table vs uncapped linear stats, pitfalls, and checklist.
• Game weak point and breakable part systems explained: targeting, damage routing and boss design Combat targeting — static and conditional weak-point taxonomy, part HP budgets and destruction state machines, hit routing and multiplier stacking, Harbor Siege siege-engine refactor, technique decision table vs flat HP sponges, pitfalls, and checklist.
• Game contextual interaction prompt systems explained: focus, hold-to-use and priority stacks World UX — proximity vs raycast focus, tap vs hold input profiles, priority tiers when objects overlap, world-space vs HUD prompts, quest gating, multiplayer locks, Harbor Ruins refactor, technique decision table vs trigger volumes, pitfalls, and checklist.
• Game area and zone transition systems explained: boundaries, loading gates and seamless travel Zone transition design — hard boundary, portal and streaming handoff taxonomy, request-ready-commit pipeline, spawn validation, state carry-over tiers, multiplayer authority, Harbor Siege district refactor, technique decision table vs fast travel and checkpoints, pitfalls, and checklist.
• Game health and damage systems explained: HP, shields, formulas and death Survivability design — HP pools, shields and armor, damage types and resistances, additive vs multiplicative formulas, healing and regen, death and knockdown hooks, UI feedback, multiplayer authority, genre patterns, and a production checklist.
• Game elemental damage systems explained: types, resistances, procs and buildcraft Fire, frost, lightning and poison typing — resistance and weakness math, proc pipelines and elemental combos, armor penetration, Harbor Ruins ARPG refactor, technique decision table, pitfalls, and checklist.
• Game critical hit systems explained: crit chance, multipliers, RNG and pity Crit chance and damage multipliers, additive vs multiplicative stacking, RNG seeds and combat logs, variance vs expected DPS, pity and bad-luck protection, Harbor Ruins dagger refactor, technique decision table, pitfalls, and checklist.
• Game shield and barrier systems explained: overshields, absorption, regen and break Flat HP shields, percentage absorption, timed barriers, elemental typing, overshield caps, decay and regen curves, damage pipeline order, shield break feedback, Harbor Ruins frost-knight refactor, technique decision table, pitfalls, and checklist.
• Game healing and lifesteal systems explained: HoT, vampirism, anti-heal and combat sustain Burst vs heal-over-time, physical lifesteal vs spell vamp, overheal rules, damage pipeline placement, heal reduction debuffs, combat regen caps, Harbor Ruins blood-knight refactor, technique decision table, pitfalls, and checklist.
• Game attack telegraphing explained: windups, visual tells and fair reaction windows Readable combat design — windup-active-recovery phases, animation and audio tells, ground AoE markers, boss pattern vocabulary, accessibility options, Harbor Ruins frost knight refactor, technique decision table, pitfalls, and checklist.
• Game boss phase systems explained: HP gates, moveset swaps and arena transitions Multi-phase encounter pacing — HP and stagger gates, mechanic objectives, transition invulnerability, pattern escalation, arena mutations, Harbor Ruins frost knight refactor, technique decision table vs flat HP sponges, pitfalls, and checklist.
• Game down-state and revive systems explained: bleed-out, incapacitation and squad recovery Co-op tension design — bleed-out timers, crawl and limited agency, hold-to-revive channels, self-revive kits, shared lives and squad wipe rules, finisher interrupts, Harbor Outpost raid refactor, genre decision table, pitfalls, and checklist.
• Game stamina and resource systems explained: regen, costs, survival meters and combat economy Stamina, mana, hunger and action points — drain and regen curves, exhaustion breakpoints, survival loop coupling, multiplayer authority, genre patterns, decision table, and a production checklist.
• Game ability cooldowns explained: timers, charges, GCD and CDR balance Ability pacing design — flat cooldowns, charge stacks, global cooldown, shared school lockouts, channel rules, CDR caps and haste math, HUD feedback, multiplayer authority, genre patterns, and a production checklist.
• Game harvesting and gathering systems explained: resource nodes, tool tiers and respawn design World economy faucets — node FSMs and interaction holds, tool category gates and tier multipliers, yield tables and bonus rolls, per-player vs global respawn, multiplayer authority, Harbor Outpost biome refactor, technique decision table vs auto-loot and vendors, pitfalls, and checklist.
• Game crafting systems explained: recipes, stations and economy sinks Recipe schemas and ingredient validation — crafting stations, instant vs timed production, quality tiers, unlock progression, salvage loops, multiplayer authority, UI patterns, and a production checklist.
• Game shop and vendor systems explained: catalogs, pricing spreads and economy sinks NPC commerce design — buy and sell catalogs, base value registry, asymmetric spreads, stock rotation and purchase caps, reputation discounts, UI patterns, multiplayer authority, Harbor Outpost trading post refactor, technique decision table vs barter and auction houses, pitfalls, and checklist.
• Game cutscenes explained: timelines, camera rails, skip logic and cinematics Scripted cinematic interruptions — in-engine vs FMV, sequencer tracks and bindings, spline cameras, input lock, skip fast-forward state, dialogue and VO sync, streaming transitions, multiplayer sync, 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 GOAP explained: goal-oriented action planning, world state and emergent NPC plans Symbolic world state, action preconditions and effects, A* planning over action chains, replanning triggers, hybrid utility/BT stacks, Harbor Outpost colonist worked example, approach decision table, pitfalls, and checklist.
• Game reputation and faction systems explained: standing, consequences and world reactivity Per-faction standing tiers — karma vs faction rep, ally/enemy matrices, economy and combat consequences, witness pipelines, Harbor Settlement guard refactor, technique decision table, pitfalls, and checklist.
• Game NPC daily schedules explained: routines, time slices and world simulation Time-of-day routines — schedule segments and anchors, activity tags and variants, world-time compression, interruption priority stack, quest overrides, persistence and multiplayer sync, Harbor Settlement market-day refactor, technique decision table, pitfalls, and checklist.
• Game companion AI design explained: party members, follow behavior and combat assist Companion archetypes and autonomy spectrum, formation slots and doorway yield, combat assist priority stacks and DPS caps, bark systems and personality, Harbor Ruins escort refactor worked example, architecture decision table, pitfalls, and checklist.
• Game minion and summon systems explained: caps, AI stacks and multiplayer authority Player-owned combat entities — taxonomy (minion vs deployable vs pet), spawn gates and population budgets, behavior stacks and leash rules, aggro contribution, Harbor Outpost engineer refactor, technique decision table vs companions and wave spawns, pitfalls, and checklist.
• Game hotbar and quickslot systems explained: action bars, binding and combat UX Combat-facing slot design — ability vs consumable vs weapon taxonomy, input binding and paging, cooldown overlays, inventory linkage and loadout presets, weapon wheels vs linear bars, Harbor Ruins HUD refactor, technique decision table, pitfalls, and checklist.
• Game channeling and cast-time systems explained: windups, interrupts and readable spells Cast timing taxonomy — instant vs windup vs channeled vs charge-up, interrupt and silence FSM, movement and LoS rules, cast-bar UX, Harbor Ruins archmage refactor, technique decision table vs instant cooldowns, pitfalls, and checklist.
• Game damage over time (DoT) systems explained: ticks, stacking and snapshot math DoT taxonomy — fixed, ramp, aura and channeled ticks, global scheduler vs per-instance timers, snapshot vs dynamic scaling, pandemic refresh, bleed/poison/burn archetypes, Harbor Swamp witch-doctor refactor, technique decision table vs burst damage, pitfalls, and checklist.
• Game boss fight design explained: phases, telegraphs, arenas and pacing Memorable climax encounters — health-gated phases, attack telegraphs and recovery windows, arena layout and hazards, checkpoint policy, boss archetypes, co-op scaling, accessibility toggles, anti-patterns, and a production checklist.
• Game monetization explained: F2P, IAP, ads, subscriptions and ethical revenue design Revenue models that respect players — premium vs F2P, IAP pricing tiers and psychology, ad formats, battle passes, whale economics, platform fees, regulation, worked example, decision table, and checklist.
• Game reward schedules explained: variable ratio reinforcement, streaks and ethical retention Operant conditioning in games — fixed and variable interval/ratio schedules, daily login calendars, loot anticipation, streak forgiveness, Harbor Puzzle D7 retention redesign worked example, schedule decision table, pitfalls, and checklist.
• Game user acquisition and marketing explained: CPI, LTV, creatives and funnel optimization Paid and organic install funnels — CPI, IPM, ROAS and LTV metrics, Meta/TikTok creative testing, ASO, influencer whitelisting, cross-promo, Harbor Puzzle mobile launch worked example, channel decision table, pitfalls, and checklist.
• Game community management explained: Discord, moderation, UGC and crisis response Platform choice and lifecycle staffing, moderation stacks and volunteer mod training, creator programs and feedback routing, sentiment metrics, Harbor Arena Season 4 Discord rollout worked example, platform decision table, pitfalls, and checklist.
• 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 core loop design explained: micro, session and meta loops that drive retention Action-feedback-reward cycles — micro vs session vs meta loop layers, genre loop patterns, layering without bloat, Harbor Arcade Coin Foundry worked example, loop architecture decision table, measurement metrics, pitfalls, and checklist.
• Game AI director design explained: dynamic pacing, tension curves and adaptive encounters Invisible pacing orchestration — intensity meters and tension/release cycles, spawn budgets and rest beats, player-state inputs, genre patterns for horror and co-op hordes, Harbor Escape worked example, architecture decision table, pitfalls, and checklist.
• Emergent gameplay design explained: systemic verbs, interactions and unscripted moments Designing for player-discovered outcomes — interaction matrices, feedback loops, emergence vs chaos, genre patterns across sandbox and sim, Harbor Foundry worked example, decision table, pitfalls, and checklist.
• 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 playtesting and QA explained: sessions, bug triage and usability feedback Structured player observation before launch — vertical slice and FTUE usability sessions, think-aloud vs silent play, severity triage, Harbor Arcade Coin Foundry worked example, playtest type decision table, pitfalls, and checklist.
• Game anti-cheat explained: server authority, detection methods and fair play Protect competitive integrity — aimbot and speedhack threat models, server-side validation, EAC and BattlEye tradeoffs, behavioral scoring, replay forensics, false-positive appeals, privacy concerns, 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 ragdoll physics explained: joints, blending and death animation Articulated rigid-body corpses — ball and hinge joints, passive vs active ragdolls, animation blend curves, collision layers, performance caps, multiplayer sync, engine notes, and a production checklist.
• Game replay systems explained: input recording, determinism and rollback netcode Match time machines — input logs vs state snapshots, seeded determinism and checksums, ghost racers, rollback rewind machinery, spectator delay, replay file versioning, anti-cheat re-simulation, playback UX, genre decision table, and a production checklist.
• Game stealth mechanics explained: visibility, sound, cover and detection Player-facing stealth systems — light and posture visibility, noise events and propagation, hard vs soft cover, disguise and social infiltration, detection meters, takedowns, level routing, accessibility assists, and a production checklist.
• 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 inverse kinematics explained: two-bone IK, foot planting and aim constraints Forward vs IK, analytic two-bone solvers and pole vectors, CCD and FABRIK, foot raycast planting and pelvis offset, look-at and hand grip IK, Unity Animation Rigging and Unreal Control Rig, Harbor Ruins archer refactor worked example, method decision table, pitfalls, and checklist.
• Game vehicle physics explained: wheel colliders, suspension, grip and arcade vs simulation Arcade vs sim-lite tuning, rigid-body chassis and CoM, spring-damper wheel colliders, torque curves and gearing, slip angles and drift assists, aero downforce, Unity WheelCollider and Unreal Chaos Vehicle, Harbor Arena coastal circuit refactor worked example, approach decision table, pitfalls, and checklist.
• 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 dynamic music explained: adaptive audio, stems, intensity layers and middleware Interactive scores that follow gameplay — horizontal re-sequencing vs vertical stem mixing, intensity layers and hysteresis, FMOD and Wwise workflows, combat transitions, memory budgets, anti-patterns, and a production checklist.
• 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 day-night cycle explained: time systems, sky, lighting and schedules World clocks and accelerated time — sun and moon arcs, sky gradients and atmospheric scattering, golden-hour lighting, NPC routines and shop hours, stealth and survival mechanics, multiplayer sync, performance traps at dusk, and a production checklist.
• Game weather systems explained: rain, snow, wind and atmosphere Storms that feel systemic — weather presets and blended transitions, precipitation particles, surface wetness, wind on foliage, gameplay hooks, audio layers, performance budgets, biome climate tables, multiplayer sync, 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 encounter design explained: composition, arenas, telegraphs and scaling Set-piece challenges beyond raw spawning — enemy roles and threat budgets, arena layout and cover geometry, telegraphs and readability, authored vs procedural packs, co-op scaling, rewards, genre patterns, and a production checklist.
• Game enemy scaling systems explained: level curves, zone tiers and power matching Open-world power matching — fixed vs dynamic stat curves, zone tiers and level-delta modifiers, over-level reward suppression, co-op HP multipliers, Harbor Ruins refactor, technique decision table, pitfalls, and checklist.
• Game dynamic difficulty adjustment (DDA) systems explained: performance signals, rubber-banding and fair tuning Adaptive challenge from live performance — struggle scores, assist tiers, telegraph and resource nudges, hidden vs disclosed policy, AI director hooks, Harbor Spire 73→31% churn refactor, decision table vs static curves, pitfalls, and 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 haptics and rumble explained: controller feedback, DualSense and mobile vibration Tactile game feedback — impulse vs continuous rumble, Gamepad API and DualSense adaptive triggers, haptic design tiers, layering and priority, sync with audio and hit-stop, accessibility toggles, browser limits, 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 interaction systems explained: use keys, raycasts, prompts and context actions World interaction plumbing — proximity and raycast detection, interactable components, priority queues, tap vs hold prompts, diegetic UI, quest and inventory hooks, multiplayer authority, accessibility, and a production checklist.
• 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 encumbrance and weight systems explained: carry limits, movement penalties and loot pacing Encumbrance taxonomy — slot vs hard weight vs soft tiers, penalty curves and stamina links, item weight assignment, UI preview, multiplayer pools, Harbor Siege supply-run refactor, technique decision table vs slot-only caps, pitfalls, and checklist.
• Game item pickup and loot collection systems explained: magnets, proximity and grant pipelines World-to-inventory bridge — pickup mode taxonomy, entity lifecycle, magnet radius and fly-to-player arcs, full-bag filters, multiplayer authority, Harbor Siege vault refactor, technique decision table vs manual interact-only, pitfalls, and checklist.
• Game equipment and loadout systems explained: slots, stat aggregation and preset swaps Equipment vs inventory vs loadout presets, slot taxonomy and restriction rules, stat aggregation pipelines, paper-doll vs list UI, quick-swap presets, transmog separation, Harbor Chronicles raid refactor, technique decision table, pitfalls, and checklist.
• Game item durability and repair systems explained: wear curves, break states and economy sinks Gear degradation design — wear-on-use vs wear-on-hit, soft vs hard break states, repair benches and field kits, material costs, expedition warnings, Harbor Outpost gear loop refactor, technique decision table vs indestructible gear, pitfalls, and checklist.
• Game item rarity and affix systems explained: tiers, modifiers and power budgets Rarity tier taxonomy, prefix/suffix/implicit affix pools, budget-point roll math, color beams and compare UI, ilvl content banding, unique and set bonuses, Harbor Siege loot presentation refactor, technique decision table vs flat stat items, pitfalls, and checklist.
• 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 scene management and screen flow explained: loading, transitions and navigation Scene stacks and navigation — scenes vs screens, async loading screens, fade transitions, pause and modal overlays, memory unload rules, session state tiers, multiplayer ready gates, engine patterns, and a production checklist.
• 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 pathfinding and navmesh explained: A*, graphs, baking and local avoidance Grid vs navmesh graphs, A* search and funnel smoothing, agent radius baking, dynamic obstacles and carving, steering plus RVO avoidance, flow fields for hordes, multiplayer authority, performance budgets, and a production checklist.
• 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 skill trees explained: branching unlocks, respec and build balance Talent and skill point design — active vs passive nodes, prerequisites and keystones, point economies, trap choices, respec policy, tree UI patterns, multiplayer balance, and a production checklist.
• Platformer game design explained: level flow, gaps, verticality and genre patterns Genre variants from linear 2D to metroidvania, teach-test-twist level geometry, gap and hazard pacing, moving platforms and gimmicks, camera readability, exploration loops, World 1-1 worked example, format decision table, pitfalls, and a production checklist.
• Game one-way platform and drop-through systems explained: soft collision, layer masks and vertical level design Stacked route geometry — one-way collision from below, down+jump drop-through input, physics layer matrix, Harbor Peaks 32→71% optional-path completion case, technique decision table vs solid-only floors, pitfalls, and checklist.
• Idle game design explained: prestige, offline progress and incremental loops Core tap-and-wait loops, exponential cost curves, prestige resets and meta-progression, offline earnings caps, automation tiers, anti-idle paradox, mobile cookie-factory worked example, genre decision table, pitfalls, and a production checklist.
• Game horror design explained: tension, dread, pacing and scare craft Fear vs dread vs disgust, horror subgenre contracts, tension-release cycles, anticipation and uncertainty, audio and lighting as threat tools, enemy encounter tiers, jump scare discipline, corridor worked example, genre decision table, accessibility, and a production checklist.
• Game survival mechanics explained: hunger, shelter, scarcity and the core loop Vital meters and staged penalties, shelter and base progression, scarcity and encumbrance, threat escalation, day/night and weather coupling, permadeath tiers, multiplayer authority, island worked example, genre decision table, pitfalls, and a production checklist.
• Game open world design explained: agency, discovery, density and traversal Spatial rhythm and POI density, landmark sightlines, traversal and fast-travel economics, quest integration without railroading, dynamic events, world streaming, multiplayer authority, coastal region worked example, genre decision table, pitfalls, and a production checklist.
• Game level streaming explained: world partitioning, async loading and seamless open worlds Uniform grid and manual zone partitioning, three-ring load/unload policies, async IO pipelines, seamless vs zoned transitions, cross-cell persistence, Harbor Outpost coastal refactor worked example, architecture decision table, pitfalls, and checklist.
• Game crowd simulation explained: steering behaviors, flow fields and performance Reynolds separation/alignment/cohesion, flow fields and navmesh density masks, crowd LOD and impostors, tiered scheduling and threading, Harbor Outpost market square refactor worked example, architecture decision table, pitfalls, and checklist.
• Game deck-building card design explained: synergies, draw economy and roguelike runs Draw/discard/exhaust piles, mana and energy curves, keyword synergies, roguelike reward pacing, variance control, card UI readability, monetization ethics, poison archetype worked example, format decision table, and a production checklist.
• Trading card game design explained: sets, metagame, limited draft and balance CCG vs LCG formats, set design and rarity curves, mana curves and keywords, limited draft vs constructed metagame, collection monetization ethics, balance patches and rotation, Harbor Parlor TCG worked example, format decision table, pitfalls, and checklist.
• Game puzzle design explained: fair constraints, hint systems and the eureka moment Logic and spatial puzzle taxonomy, teach-then-test onboarding, constraint clarity, tiered hint ladders, difficulty pacing, procedural vs hand-crafted tradeoffs, worked lock example, genre table, and a production checklist.
• 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 locomotion explained: character controllers, movement feel and platformer physics Kinematic vs dynamic controllers, ground probes and coyote time, acceleration curves, jump buffers, slope and stair stepping, root motion vs in-place, genre patterns, networked prediction, 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 balancing explained: power curves, economy tuning and fair play Combat DPS and TTK math, progression power curves, economy faucets and sinks, multiplayer fairness patterns, spreadsheet workflows, data vs feel iteration, live-ops patch cadence, genre tables, and a production checklist.
• Game battle pass design explained: season tracks, challenges and monetization Live-service retention design — free vs premium tracks, season tier and XP math, daily and weekly challenges, catch-up mechanics, monetization ethics, genre patterns, server-side implementation, and a production checklist.
• Game metaprogression design explained: permanent unlocks, prestige and run layers Progression above the run — account vs session vs seasonal layers, prestige resets, unlock trees and meta currencies, roguelite stat vs variety curves, veteran gap mitigation, Harbor Escape mirror unlock worked example, model decision table, pitfalls, and checklist.
• Game live-ops and seasonal content design explained: cadence, events and retention Post-launch operations — content cadence layers, season pillars, production calendars, return triggers and player segmentation, economy integration, Harbor Arena Season 4 rollout worked example, live-ops model decision table, pitfalls, and checklist.
• Environmental storytelling in games explained: show-don't-tell level design Diegetic narrative through layout, props, lighting, and audio — mise-en-scène, breadcrumb trails, contrast and decay layers, genre density patterns, quest integration, accessibility pitfalls, and a level-design checklist.
• Game faction and reputation systems explained: standing, consequences and design Faction vs reputation layers, standing tiers and thresholds, gain and loss triggers, vendor and quest gates, alignment vs politics, multi-faction tradeoffs, implementation patterns, genre table, 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 procedural quest generation explained: templates, planners and narrative coherence Quest grammars and typed slot filling, world-state preconditions, solvability validation and GOAP-style planners, narrative stitching and quest memory, Harbor Outpost contract board worked example, approach decision table, pitfalls, and checklist.
• Game asset pipeline explained: import, compression, bundling and CI validation DCC export presets and folder conventions, texture platform compression and resolution tiers, mesh LOD and collision derivation, addressable bundles and streaming, Git LFS and art depots, CI budget gates, Harbor Arena Season 2 refactor worked example, approach decision table, pitfalls, and 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.
• Tower defense game design explained: paths, towers, waves and economy Lane vs maze pathing, tower role triangles and synergies, enemy archetypes, wave scripting, gold curves and sell rules, upgrade trees, campaign level-5 worked example, subgenre decision table, pitfalls, and a production checklist.
• Game procedural generation explained: PCG pipelines, seeded RNG, dungeons and WFC Algorithmic content at scale — seeded determinism, BSP and graph grammars, Wave Function Collapse, hybrid handcrafted kits, loot and encounter parameterization, solvability validation, multiplayer authority, performance budgets, 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.
• Roguelike game design explained: permadeath, procedural runs and meta-progression Run-based replayability — roguelike vs roguelite, chunk-based procedural dungeons, in-run build synergies, meta-unlock pacing, fair RNG and pity systems, ironman saves, run summary UX, 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.
• Game status effects explained: buffs, debuffs, DoT, CC and stacking Combat modifiers and buildcraft — buff/debuff data models, stacking and refresh rules, stat modifier order, DoT/HoT ticks, crowd control and DR, cleansing, buff bar UI, multiplayer authority, 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 post-processing explained: bloom, tonemapping, DOF and screen effects Screen-space polish after the main render — HDR pipelines, bloom and SSAO, depth of field, motion blur, color grading LUTs, TAA, quality presets, mobile and WebGL budgets, and a production checklist.
• 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 ranked placement and calibration systems explained: seeding, hidden MMR and fair ladder entry Placement FSM, K-factor inflation, opponent-weighted updates, season carry-over priors, party sigma rules, smurf acceleration, Harbor Arena 44→11% misplacement churn refactor, decision table vs fixed seed, pitfalls, and checklist.
• Game ranked decay and inactivity systems explained: MMR drift, LP loss and season resets Competitive ladder hygiene — hidden MMR drift curves, visible LP decay at top tiers, grace periods, soft vs hard season resets, placement re-entry, Harbor Brawl ranked refactor, technique decision table vs no-decay ladders, pitfalls, and checklist.
• Game ranked demotion protection and shield systems explained: LP shields, promo series and grace games Post-promotion LP shields, demotion grace games at 0 LP, promo-series FSM handoff, promotion MMR clamp, party shield rules, Harbor Arena 46→8% tilt-quit refactor, decision table vs instant demotion, pitfalls, and checklist.
• Game throw break and tech systems explained: tech windows, mash layers and counterthrows Throw loop prevention — tech window timing, directional breakaways, counterthrow priority, throw-break meters, mash option selects, Harbor Brawl grappler refactor, technique decision table vs grab-only defense, pitfalls, and checklist.
• Game tick throw systems explained: frame advantage, jump startup and grappler pressure Plus-frame throw coercion — tick window math, jump startup vulnerability, kara tick routes, defender option tables, Harbor Brawl grappler refactor, technique decision table vs shimmy-only pressure, pitfalls, and checklist.
• Game minimap explained: layout, rendering, fog of war and navigation Corner HUD vs full-screen tactical maps — orthographic rendering, baked terrain textures, icon layers, fog bitmask sync, click-to-move routing, north-up vs heading-up rotation, performance budgets, multiplayer authority, and a production checklist.
• 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 pacing explained: tension curves, rhythm and player fatigue Emotional rhythm over time — macro acts vs micro encounter beats, tension and release curves, breather rooms, genre heartbeat patterns, playtest fatigue signals, decision table, 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.