Video courses to master iOS development. Written guides to deepen your knowledge. Start free, go pro when you're ready.
Revenue, paywall, ASO, growth loops — broken down with importable templates you can drop into your own app.
Watch, code along, and build real apps. Structured like a bootcamp — start at the top, work your way down.
Start with setup, build Swift and SwiftUI foundations, then move into projects, APIs, media, platform features, publishing, and marketing.
In-depth written tutorials with code examples. Read at your own pace, copy-paste into your projects.
All articles are freeSet up your Mac, install Xcode, create your first playground, and write your first line of Swift code.
What Swift is, where it came from, the full learning roadmap from basics to building your own types.
How computers handle numbers, Swift arithmetic, binary & hex, and storing data with let and var.
Type conversion, type inference, strings, string interpolation, tuples, Unicode, and numeric types.
Booleans, comparison operators, if/else, ternary operator, while loops, repeat-while, and scope.
For loops, ranges, switch statements, pattern matching, partial matching with tuples, and labeled statements.
Parameters, argument labels, return values, tuples, inout, overloading, and functions as values.
nil, force unwrapping, optional binding (if let), guard let, nil coalescing, and safe coding patterns.
Ordered arrays, key-value dictionaries, unique-value sets, performance characteristics, and Big-O notation.
Closure syntax, capturing, trailing closures, and functional operations — map, filter, reduce, compactMap, lazy collections.
Unicode, grapheme clusters, string indexing, substrings, raw strings, character properties, and UTF-8/UTF-16 encoding.
Pattern matching with Swift regex literals and RegexBuilder — character classes, repetitions, anchors, captures, and TryCapture transforms.
Defining your own value types in Swift — properties, methods, mutability, value semantics, and protocol conformance with CustomStringConvertible.
Stored vs computed properties, get/set, type properties with static, willSet/didSet observers, and lazy initialization.
Methods, self, initializers, mutating methods, type methods with static, and extending existing types with extension.
Classes vs structs in Swift — reference semantics, the heap, object identity with ===, shared mutation, and when to reach for which.
A beginner's mental model — browsers, DNS, HTTP, servers, databases, CDNs — plus the full 25-chapter roadmap from zero to shipping a SaaS on Cloudflare.
What HTML actually is, how the browser turns it into a DOM tree, the 20 elements you'll use 90% of the time, semantic structure, forms, and five accessibility rules that make pages work for everyone.
Rule anatomy, the 8 selectors you'll actually use, specificity, the box model, flexbox, grid, positioning, and responsive media queries — everything to turn unstyled HTML into a shippable page.
Turn ad-hoc CSS into a scalable system: custom properties, tokens, typographic scales, spacing rhythms, dark-mode theming, and reusable primitives — the pattern every polished product site uses.
The third leg of the browser: variables, functions, arrays and objects, the DOM, events, fetch, async/await, modules, localStorage — with the patterns for every real-world task.
The Part 1 capstone. A full walkthrough of the real Next.js + MDX + Cloudflare stack behind this website — file tree, request lifecycle, MDX pipeline, mermaid interception, dark-mode tokens, deploy.
Part 2 starts here — the concepts every server-side tutorial assumes: client vs server, REST resources + verbs, JSON shape, status codes, stateless requests, idempotency, and how to design a clean API before writing code.
Install Wrangler, scaffold a project, understand the fetch handler, route GET/POST/DELETE requests, handle CORS, add a secret, test locally with wrangler dev, and ship a live JSON API to 300+ edge cities.
A plain-English SQL crash course plus Cloudflare D1: tables, the 6 queries that cover 95% of real work, foreign keys, indexes, migrations, prepared statements, and making your notes survive any restart.
Cloudflare R2 explained from scratch: what object storage is, bucket basics, put/get/delete/list, uploading from HTML forms, streaming through a Worker, CDN caching, and the D1 + R2 split for every content-heavy app.
Authentication vs authorization, password hashing with PBKDF2, sessions vs tokens, cookies vs Authorization headers, and building HS256 JWT signing in a Worker with the Web Crypto API — 40 lines, no libraries.
The full Authorization Code Flow explained and implemented in a Worker: Google Cloud setup, every URL in the dance, CSRF-safe state handling, code-for-token exchange, and issuing a session once the user is known.
Turn your Worker into a real SaaS backend: configure Stripe products, redirect users to hosted Checkout, verify signed webhooks, handle subscription state transitions, gate premium features — and keep 97% instead of 70%.
The Part 2 capstone. Open the real Worker behind simpleappshipper.com — hand-written JWT, Google OAuth, Stripe webhooks, D1, R2 with perceptual-hash dedup, and a 5-min cron — and recognise every pattern from Chs 7–13.
Stop being confused about CI. What continuous integration actually does, why a green check gates the merge button, what a GitHub Actions workflow runs on a fresh Linux VM, why `npm ci` is not a typo for `npm install`, and a copy-pasteable workflow that auto-deploys a Worker on every push to main.
The two tools every modern JavaScript project ships with. What ESLint catches (bugs and bad patterns), what Prettier rewrites (whitespace and quotes), why they're two tools, how to wire them into VS Code and into CI with a `format:check` gate.
What a unit test actually is, why Vitest is the modern default, the Arrange-Act-Assert structure, what to mock and what to leave alone, testing async code, what code coverage really tells you, and how `npm test` becomes a CI gate that blocks regressions.
Branches, forks, draft PRs, merge vs rebase vs squash, fixing conflicts without panic, what a commit SHA is and why PRs link to them, and the anatomy of a PR description a reviewer actually wants to read. A from-zero guide for anyone who's only pushed to main.
What a reviewer actually looks for, how to write comments people don't hate receiving, the difference between approve / request changes / comment, how to disagree without going to war, and how to read review feedback without taking it personally.
What a .jsx file is, what makes .tsx different, what an .mdx file actually is, what TypeScript adds on top, and a full walkthrough of `npm run lint`, `npm run typecheck`, `npm test`, `npm run build`, and `npm run dev` — and how they all flow into the CI pipeline.
What CI actually costs and how to pay nothing for it. Why public repos are free forever, the macOS 10x trap on private repos, Cloudflare's built-in push-to-deploy as an alternative, the four ways to run the same checklist locally for $0 (git hooks, act, self-hosted runners), and a side-by-side price comparison.
The tooling under every JavaScript project, from zero: what a package is, what the npm registry is, what package.json, node_modules, and package-lock.json each do, dependencies vs devDependencies, how the ^ and ~ in version numbers work, local vs global installs, what npx is and why it exists, npm vs npx side by side, the real applications of each (scaffolding apps, running a tool once, pinning a version), a command cheat sheet, and where pnpm/yarn/bun fit.
Five terms you keep bumping into while shipping an app — in your terminal, in git's output, in the project docs — finally explained from zero. What SQL is, what a schema is (the blueprint of your data), what Cloudflare D1 is as a technology (serverless SQLite at the edge), what git means by 'the working tree is dirty' (you have unsaved changes, and that's fine), and the most useful idea of the bunch — 'source of truth': the one authoritative copy everything else derives from, and how to use it. Plain-English definitions with links to the deep-dive chapters.
For the moment CI stops being free: when you're shipping macOS builds and the 10x runner tax starts billing real money. Cloudflare Workers Builds as a real build pipeline, a head-to-head against the same deploy on GitHub Actions, a click-by-click tour of where the bill actually lives on both dashboards (and how to cap it at $0), and the buy-vs-rent math for a ~$599 headless Mac Mini that pays for itself in about four months — plus a no-monitor self-hosted-runner setup guide.
The same checklist runs in two places: your laptop before you push (ci:local) and a rented VM after. What local CI actually is, why this project ships an `npm run check` gate, the one rule that stops local and online drifting (one script, two callers), an honest pros-and-cons of each, a full catalog of where to run the checks — git hooks, Husky/lefthook, act, Docker, self-hosted runners vs GitHub Actions, Workers Builds, CircleCI, Bitrise, Codemagic, Xcode Cloud — and how the two layers cover for each other instead of competing.
27 chapters, three tiers: static HTML → Cloudflare Workers + D1 + R2 → Next.js 16 on Cloudflare. Parts 1 + 2 complete plus the operational-workflow track (CI, lint, tests, PRs, review, file types, CI cost, build economics, local vs online CI, npm/npx) — 25 chapters live; Part 3 modern-frontend track starts next.
The shipping & DevOps side of iOS — the part the language tutorials skip. Ch 1: do you even need CI for an iOS app? The macOS 10x runner tax, why code signing (not the build) is the hard part, Xcode Cloud vs Bitrise vs Codemagic vs fastlane, and four ways to build and push to TestFlight from your own Mac for $0. Code signing, TestFlight automation, screenshots, and App Store review coming next.
The full DevOps picture — commit to production, with AI agents in the loop. Ch 1: the whole board — the five gated acts every change passes through (author, propose, verify, ship, operate), where agents may act and where a human must stay (agents propose, humans dispose), the non-negotiable principles, the one common shape behind five targets (Cloudflare web, iOS, Android, Mac, Windows), and a reference architecture for a real indie fleet — one always-on Mac mini + several MacBook Pros. Ch 2: the agent-assisted pull request — author vs reviewer agents, the four-layer review funnel, the review→edit→pass loop, least-privilege guardrails, and security traps. Then cross-platform CI (one DAG, five targets), the hardened Mac mini + MacBook Pro build cluster, Cloudflare web shipping (preview deploys, gradual rollout, instant rollback), the iOS/Android/Mac/Windows app pipelines, and the production safety net — environments, secrets, observability, and recovery. All 7 chapters live.
Stop memorising git commands and actually understand them. Ch 1: how git really works (commits, the DAG, HEAD, the three trees). Ch 2: merge vs rebase vs squash and what those 'PR #N' squash-merges on your repo actually do. Ch 3: GitHub like a pro — issues, branch protection, releases, semver, and the gh CLI. Ch 4: undo anything safely — reset, revert, stash, reflog, cherry-pick. Ch 5: free vs paid — premium features, usage-based billing, Copilot, and what's actually worth it. The version-control knowledge every developer is assumed to have but nobody teaches.
The protocols and registries that make the internet actually work — the stuff every developer relies on but rarely sees explained. Ch 1: RDAP, the HTTPS+JSON replacement for WHOIS that ICANN made the official gTLD lookup protocol in January 2025. Real curl examples, the IANA bootstrap, RDAP vs WHOIS, jCard contacts, GDPR redaction, and what to actually do with it (domain availability, abuse contacts, monitoring). DNS deep-dive, BGP, and certificates coming next.
Real attacks, explained from the root cause — and how to not be the one they happen to. Ch 1: subdomain takeover — a real, redacted incident where a deleted S3 bucket let a stranger serve a gambling scam at a live domain. Why a dangling DNS record plus a claimable global name equals a full domain hijack with zero code injected, the AI-agent migration mistake that opened the door, the incident-response order that stops the bleeding in minutes, and the pre-flight checklist that makes it impossible. Ch 2: is my domain hacked? — the outside-in field guide. The exact whois/dig/curl method to tell a misconfiguration from a real breach (and the VPN fake-IP trap that fools you), the full map of all nine dangling-pointer variants, and the 15-minute quarterly audit — with a copy-paste Cloudflare sweep — that finds them on every domain you own before a scanner does. XSS, secrets in frontend code, CSRF, and supply-chain attacks coming next.
The real production playbook for shipping a paid video-course site on Cloudflare's stack — the same architecture this site runs on. Ch 1: the whole stack at a glance + the bill at three scales. Ch 2: streaming video on R2 ($0 egress vs Stream's per-minute model — when each wins). Ch 3: Google OAuth + JWT sessions and Stripe subscriptions in a Worker (the no-Apple-IAP play). Ch 4: the paywall — server-side gates for videos and SEO-safe article paywalls. Everything you need to launch for $0 and the upgrade path as you scale.
The two frameworks every JavaScript developer asks about — explained, compared, and made small. Ch 1: why a framework at all, and the Astro-vs-Next decision (content site vs app, ship-zero-JS vs React-everywhere, the Cloudflare bill for each). Ch 2: file-based routing and the question every reader asks at some point — what does `[slug]` actually mean? Static routes, dynamic routes, catch-all routes, in both. Ch 3: canonical URLs, route params vs query params, generateStaticParams / getStaticPaths, trailing slashes, redirects, and the SEO things people forget. Ch 4: MDX, Astro Islands vs Next.js Server Components, and deploying both onto Cloudflare via @astrojs/cloudflare and OpenNext.
The layer after the basics. You've shipped your first Worker (web Ch 8), wired KV (Cloudflare Ch 4), and have JWT sessions running (web Ch 11) — now the production-readiness layer. Ch 1: caching done properly (Cache-Control, the four caches your app uses, KV-as-cache, ETag/304). Ch 2: rate limiting + abuse prevention (Cloudflare Rate Limiting Rules vs DIY Durable Objects, per-user vs per-IP, 429 + Retry-After). Ch 3: webhooks that don't lose data (HMAC verify, idempotency, retries, the raw-body trap). Ch 4: background jobs (Cron Triggers + Workers Queues — when each beats the other). The boring infrastructure that turns a demo into a product.
A working tour of the Cloudflare stack we ship on every day: Workers, R2, D1, KV, Durable Objects, and Workers AI. Each chapter is a feature-focused deep dive — what it is, the binding API, real production code from this site's backend, pricing, and an honest list of where it still loses to AWS/Postgres/closed-source. Start with the video-streaming case study, then walk through each primitive in order.
S3-compatible object store with $0 egress. Bucket bindings, put/get/head/list/delete, multipart uploads, public vs Worker-proxied access, the real production code that backs 60 GB of tutorial videos on simpleappshipper.com — and a clear list of where R2 still loses to S3.
A globally-distributed SQLite database wired into your Worker. Prepared statements, .first / .all / .run, batch transactions, schema migrations, the real production schema this site runs, read replicas via the Sessions API, and the honest list of where D1 still loses to Postgres.
A read-optimised key-value store replicated to every edge PoP — eventually consistent within ~60 seconds. When KV beats D1 (and when it's the exact wrong choice — counters, anything mutating across regions). TTLs, list pagination, and the read-through cache pattern that works.
Tiny single-instance actors with transactional storage that solve the problems KV and D1 can't — exactly-once webhook handling, correct rate limits, real-time websockets with hibernation, per-customer coordination. When DOs replace Redis or a queue, and the trade-offs of pinning state to one location.
Run open-source models (Llama, Flux Schnell, Whisper, SDXL, BGE embeddings) straight from your Worker via the env.AI binding — no external API key. The model catalogue, the neuron-based pricing, real text/image/vision code, streaming responses, and when to fall back to OpenRouter/OpenAI/Anthropic for frontier capability.
Four places config can live — wrangler.toml, wrangler secret put, .dev.vars, and .env.local — and which goes where. What wrangler.toml declares (bindings, [vars], routes, crons), why secrets never live in it, how .dev.vars mirrors production locally, the NEXT_PUBLIC_ trap that ships keys to every browser, and the build-time-vs-runtime gotcha unique to Next-on-Cloudflare. Grounded in this site's real backend config.
LLC setup, Stripe account structure, and the business case for ASO workflows that write into App Store Connect drafts.
Why most ASO workflows stop at reports, and how keyword research should become metadata drafts, Custom Product Pages, and In-App Events.
Written walkthroughs of SwiftUI views, layouts, state management, animations, and advanced patterns. Start with Ch 1: Checking Your Tools.
Start learning for free. Upgrade when you're ready for the full bootcamp.