Lessons

In US healthcare, a service does not become revenue until it is translated into codes and paid by an insurer. This lesson explains why that gap exists, the difference between coding and billing, the revenue cycle that connects them, and why this is one of the most accessible no-degree, often-remote career switches.

There is no best architecture, only trade-offs made for a context. This lesson covers the core of the job: analyzing trade-offs between quality attributes, the build-versus-buy decision and total cost of ownership, recording decisions with ADRs, communicating a design with the C4 model, and how a switcher grows into the role.

Most systems are shaped less by what they do than by how well they must do it. This lesson covers the requirements a solution architect must extract: functional versus non-functional, the quality attributes (the -ilities) captured by ISO 25010, why NFRs drive the architecture, and how to make vague quality demands testable.

A solution architect sits between a business problem and a technical solution, and is accountable for whether the solution fits. This lesson defines the role, separates it from enterprise and technical architects, explains why the job is about judgment and trade-offs rather than coding, and shows how engineers grow into it.

Flow reacts after events; Functions participate during them. This lesson covers how Shopify Functions let you change discounts, shipping, payment options, and cart validation from inside checkout, why they run as WebAssembly compiled from JavaScript or Rust, and why that architecture replaced the old sandboxed Scripts.

When Flow and Functions run out, you reach for the API. This lesson covers the Admin GraphQL API and its calculated-cost rate limiting, webhooks and why at-least-once delivery forces you to build for duplicates, bulk operations for large datasets, and a decision framework for choosing among all four approaches.

Most store work is repetitive reaction: tag this order, email that customer, reorder when stock drops. Shopify Flow turns that into automation with a trigger-condition-action model. This lesson covers how Flow works, over 100 event triggers, worked workflows, and the important part, where Flow stops and you need something else.

The 2025 GENIUS Act turned stablecoins from an unregulated experiment into a defined instrument with reserve rules, permitted issuers, monthly attestations, and a ban on paying holders yield. This lesson covers what the law requires, why the yield ban shapes the whole business model, and the risks the rules do not remove.

Cross-border business payments are slow and expensive for structural reasons: correspondent banking, trapped pre-funded capital, and messaging that is not settlement. This lesson explains why, what stablecoins actually change, how tokenized treasuries and deposits fit, and how to read the eye-watering volume statistics honestly.

A stablecoin is a claim on an issuer that trades at a dollar because you can redeem it for a dollar. This lesson builds the mechanism: the mint-and-redeem arbitrage that enforces the peg, why reserve composition is the whole game, and what the USDC depeg and the Terra collapse each proved about how pegs actually break.

Scoped tokens and signed mandates solve authorization, not everything. This lesson covers the unsettled parts: who is liable when an agent buys wrong, why merchants and agents have opposing incentives, prompt injection as a new attack surface at checkout, agent-to-agent buying, and why the market forecasts disagree by an order of magnitude.

How do you let software spend your money without handing it your card? This lesson covers the mechanism behind agentic checkout: scoped single-use credentials like the Shared Payment Token, Google's AP2 intent and cart mandates as signed verifiable credentials, agent identification, and the guardrails that bound what an agent may buy.

You cannot understand agentic checkout without understanding checkout. This lesson builds the payment foundation: the five parties in every card transaction, the authorization-capture-clearing-settlement path, who really pays interchange, why card-not-present fraud shapes everything, and the tokenization idea that agent payments are built on.

Insurance is legally required to discriminate between risks, and legally forbidden from discriminating on protected characteristics. This lesson covers the line between them: proxy discrimination, and the rules that now govern insurer AI, the NAIC model bulletin, Colorado's SB21-169, NYDFS Circular Letter 7, and the EU AI Act.

This is where insurers actually deploy AI: pricing models that extend a century of actuarial practice, telematics that price behavior instead of proxies, claims pipelines that read photos and documents to settle simple losses fast, and fraud models that refer suspicious claims to human investigators rather than deciding them.

Insurance is a prediction business: you take money now for a promise about an uncertain future. This lesson builds the foundations, risk pooling, the premium equation, loss and combined ratios, and the insurance value chain, then shows why a business built on forecasting risk is unusually well matched to machine learning.

The JEPA idea becomes concrete in I-JEPA on images and V-JEPA 2 on video. This lesson covers the multi-block masking that makes I-JEPA work, how an action-conditioned video model becomes a world model, and how predicting representations enables planning by model-predictive control instead of a fixed policy.

Predicting a learned representation invites a trivial cheat: represent nothing. This lesson opens the JEPA machine, the context encoder, target encoder, and predictor, shows the training loop in code, explains why representation collapse is the central danger, and how asymmetry, stop-gradient, and an EMA target defeat it without negatives.

Self-supervised learning has three families: reconstruct the input, contrast augmented views, or predict in a learned embedding space. This lesson explains why the third, the joint-embedding predictive approach behind JEPA, sidesteps both wasted capacity on unpredictable pixels and hand-crafted augmentation biases.

A design is only as good as how real people use it. This lesson covers evaluating and refining: running usability tests, Nielsen's classic heuristics, designing for accessibility with WCAG, and design systems for consistency, then how a career switcher builds a portfolio and breaks into UX.

With the right problem defined, designers build the solution. This lesson covers the craft: organizing content with information architecture and user flows, sketching structure with wireframes, testing ideas with prototypes before building, and the visual UI fundamentals, hierarchy, layout, type, and consistency, that make a design clear.

Great design starts with understanding people, not pixels. This lesson covers UX research: interviews and observation done right, the difference between what users say and do, turning findings into personas and journey maps, and writing a sharp problem statement that defines the right problem to solve.

UX design is one of the most popular creative career switches, and one of the most misunderstood. This lesson defines it: the difference between UX and UI, why user-centered design beats designing for yourself, the business value of usability, and the double-diamond process that structures how designers work.

The same project can be run in very different ways. This lesson covers the two big philosophies, plan-driven waterfall and adaptive agile, how the Scrum framework works in practice, how to choose between them, and how a career switcher can earn credentials and break into project management.