The blog
Every post is written to be read top to bottom — friendly, practical, and beginner-first. Grab a coffee and start anywhere.
Blazor: Beginner to Intermediate
A twelve-part, hands-on series that takes you from your very first Blazor app to intermediate skills — components, binding, forms, routing, services, lifecycle and render modes — while building a small clinic app inspired by our system design series. Fully up to date for .NET 10.
Anatomy of a Blazor Project: Every File Explained
Program.cs, App.razor, Routes.razor, layouts, wwwroot — a guided tour of every file in a new Blazor project, so nothing feels like magic.Blazor Components: Build Once, Use Everywhere
Components are Blazor's LEGO bricks. Build a reusable PatientCard, pass data in with parameters, and compose a page from pieces.Data Binding and Events: Making Pages Interactive
Buttons, inputs and instant updates: wire up @onclick and @bind, and understand the render loop that keeps your UI in sync.Rendering Lists and Conditionals in Blazor
Render collections with @foreach, handle empty states with @if, and build a searchable patient list — the bread and butter of real UIs.Component Communication: Parameters Down, Events Up
Parameters flow down, events bubble up. Connect parent and child components with [Parameter] and EventCallback, the Blazor way.Blazor Forms and Validation, the Friendly Way
Collect input with EditForm, validate with data annotations, and show friendly error messages — building a complete add-patient form.Routing and Navigation: Pages, URLs and Parameters
Give every screen an address: page routes, route parameters, NavLink and programmatic navigation for a multi-page clinic app.Services and Dependency Injection in Blazor
Move shared logic into services and let dependency injection deliver them — plus singleton, scoped and transient explained in plain words.The Component Lifecycle: What Runs When (and Why)
OnInitialized, OnParametersSet, OnAfterRender — what runs when, where to load data, and how to avoid the classic lifecycle mistakes.Calling Web APIs from Blazor with HttpClient
Fetch live data with HttpClient and GetFromJsonAsync, handle loading and errors gracefully, and display API results in your UI.Blazor Render Modes: SSR, Server, WebAssembly — and What's Next
Static SSR, Interactive Server, WebAssembly and Auto — how each render mode works in .NET 10, how to choose, and where to take your Blazor skills next.Conversation to System Design
A seven-part, beginner-first series that takes one real conversation with a doctor and turns it into a complete database design — entities, attributes, relationships, keys and all.
Simple Conversation to System Design — Introduction
Start here: what an ER diagram is, and how a simple chat can become a working system. Part 1 of a friendly, beginner-first system design series.Chat with a Doctor to Gather Requirements
A real requirements-gathering conversation with a doctor who needs practice-management software — the first step in turning talk into a system design.Finding Entities from Conversation
How to spot entities in a plain conversation: hunt the nouns, filter out the noise, and shortlist the things your system really needs to store.Deciding Attributes for Entities
Turn entities into tables: choose attributes, understand primary keys and data types, and see the full attribute list for our clinic system.Finding Relationships Between Entities
Verbs reveal relationships. Learn one-to-one, one-to-many and many-to-many with clear examples from our doctor's clinic system.Creating Relationships Using Foreign Keys and Junction Tables
Wire the database together: how foreign keys create one-to-many links and how junction tables solve many-to-many relationships.Simple Conversation to System Design — Conclusion
The full journey recapped: from a doctor's requirements chat to a complete relational database design — all seven steps in one place.AI & Modern Coding
The wave reshaping how software gets built — assistants, agents, prompts and RAG, minus the hype.
What Is AI-Assisted Coding? A Beginner's Guide
AI pair programmers like GitHub Copilot and Claude can write code with you. What they actually do, how to use them well, and the habits that keep you learning.Vibe Coding: What It Is — and When to Trust It
Vibe coding means describing what you want and letting AI write the code. It's fast and fun, but knowing when to trust the output is a real skill. Let's build it.What Is a Large Language Model? A Friendly Explanation
LLMs power ChatGPT, Claude and Copilot — but how do they work? A jargon-free tour of tokens, training and prediction, and why models sometimes make things up.Prompt Engineering Basics for Developers
Better prompts mean better code. Practical patterns — context, examples, constraints and iteration — that make AI coding tools dramatically more useful.What Is RAG? Retrieval-Augmented Generation, Explained
How can an AI answer questions about your documents? Meet RAG: chunking, embeddings, vector search and grounded answers — explained step by step.What Are AI Agents? From Chatbots to Digital Coworkers
An AI agent is a language model with tools, memory and a goal. How agents work, what they can safely do today, and how developers fit into the loop.What Is MCP? The Model Context Protocol, Explained Simply
MCP is being called the USB-C of AI — one standard plug between AI models and your tools and data. Here's what it is and why everyone is talking about it.Web & APIs
How the web actually works, and how programs talk to each other.
What Happens When You Type a URL and Press Enter?
DNS, TCP, TLS, HTTP, HTML — in the seconds after you press Enter, a small miracle happens. Follow a request across the internet, step by step.REST APIs Explained with a Pizza Shop
GET, POST, PUT, DELETE — REST is easier than it sounds. Order a pizza with us and you'll understand resources, methods and status codes for life.REST vs GraphQL vs gRPC: Choosing an API Style
Three popular ways for programs to talk to each other — how each one works, where it shines, and a simple rule of thumb for choosing between them.JSON Explained: The Language APIs Speak
Almost every API today speaks JSON. Learn its whole grammar in one sitting — objects, arrays, values — and the common mistakes that trip up beginners.What Is WebAssembly? Near-Native Speed in Your Browser
WebAssembly lets languages like C#, Rust and Go run inside the browser at near-native speed. What it is, how it works, and why it matters for the web.C# & .NET
The stack this site is built with — friendly, powerful, and everywhere.
Why C# Is a Great First Language
Friendly syntax, a world-class free toolchain, and one language that builds web, desktop, mobile and games. Why C# deserves a spot on your shortlist.What Is Blazor? Full-Stack Web Apps in C#
Blazor lets you build interactive web apps in C# instead of JavaScript — and this very site runs on it. Here's how it works and when to choose it.async/await Explained with a Coffee Shop
Why does your app freeze? Because someone is waiting where they should be brewing. Asynchronous code explained with baristas — and C# examples.LINQ: Query Your Collections Like a Pro
Filter, sort, group and transform data in C# with a few readable lines. LINQ is the feature C# developers miss most everywhere else — learn it here.Databases & Data
Where your data lives, and how to find it fast.
SQL vs NoSQL: Which Database Should You Learn First?
Tables or documents? Rows or JSON? What each kind of database is good at, where each struggles, and a clear recommendation for your first one.What Is a Vector Database? (And Why AI Needs One)
Vector databases search by meaning, not keywords. How embeddings turn text into numbers, and how similarity search powers RAG and semantic search.Database Indexes: Why Your Queries Are Slow
The difference between scanning a million rows and jumping straight to one. How indexes work, when to add them, and the trade-offs nobody mentions.Developer Craft
The tools and habits that make you a better developer, whatever you build.