# Bob Belderbos: Process Automation Consulting and Developer Coaching

> I help companies with automation, AI adoption and fractional CTO work. It starts with a call, then a custom scope at a fixed price. Workflow first, AI second. I also coach developers in Python, Rust, and AI.

Bob Belderbos is a software engineer, consultant, and coach based in Spain, working in English and Spanish. He started on the business side (BBA, financial analyst at CHEP in Madrid, automating reporting in VBA), then spent 13 years in production software at Sun Microsystems and Oracle, around eight of them focused on support automation. One team initiative automated the resolution of around 40% of incoming x86 support calls, significantly reducing resolution times, improving customer satisfaction, and delivering substantial cost savings. Co-founded Pybites in 2016, where he designed and built its platforms, in production since. 20 years building production software; more than 150 developers coached 1:1 since 2020.

## Consulting

- [Consulting](https://belderbos.dev/consulting/): Senior technical help without hiring a CTO. Everything is custom and starts with a call, followed by a written proposal with scope, timeline and a fixed price.
- [Automation](https://belderbos.dev/consulting/#automation): Turn a manual business process into software that runs. Plain, tested code for most steps, AI only where the input is fuzzy.
- [AI adoption](https://belderbos.dev/consulting/#ai-adoption): Pick the workflows where AI pays off, add validation and human sign-off, and teach the team to use it with judgment.
- [Fractional CTO](https://belderbos.dev/consulting/#fractional-cto): Part-time technical leadership: roadmap, architecture and vendor decisions, direction for developers or an external agency.
- [Book a call]((https://calendar.app.google/fbcfDTK3EXY62JgQ9): Bring the process, not a spec.

Good fit: growing companies with a small tech team, or none, where work moves by hand between inboxes, spreadsheets and internal tools, and something changed that makes it urgent: volume outgrowing the team, a new rule that requires traceability, the one person who knows the spreadsheet leaving, or a mandate to "add AI" with no definition. Typically a process that runs weekly, takes 10+ hours of someone's time, and follows rules people could write down. Not a fit: teams that already have a spec and only need implementation (a development agency is better for that). The client owns all code and infrastructure. AI is used only where the input is genuinely fuzzy, behind validation, with a human where a mistake is expensive.

## En español

- [Inicio](https://belderbos.dev/es/): Automatización de procesos para empresas y coaching para desarrolladores
- [Consultoría](https://belderbos.dev/es/consulting/): Automatización, adopción de IA y CTO fraccional. Empieza con una llamada, después una propuesta a medida a precio cerrado
- [Sobre mí](https://belderbos.dev/es/about/): Trayectoria de Bob Belderbos
- [Contacto](https://belderbos.dev/es/contact/): Cómo contactar con Bob

## Coaching

- [Coaching](https://belderbos.dev/coaching/): One path for developers: three self-paced Python courses (first app to deployed SaaS), a self-paced Agentic AI course, a Rust cohort, and 1:1 on your own project (fixed price from EUR 1,000)
- [Python Foundations](https://belderbos.dev/foundations/): Ship your first tested Python CLI with uv, git and pytest, self-paced
- [Agentic AI Course](https://pythonagenticai.com/course/): Self-paced course, build a production AI agent in Python
- [Rust Cohort](https://scriptertorust.com): Learn Rust by building a JSON parser
- [Full-Stack Python](https://belderbos.dev/coaching/snipster/): Build Snipster, a full-stack snippet manager (CLI, API, web) with the repository pattern, self-paced
- [Django SaaS](https://belderbos.dev/coaching/signoff/): Build Signoff, a multi-tenant content calendar SaaS, in 6 weeks, self-paced
- [Coaching for Teams](https://belderbos.dev/coaching/teams/): Team seats and private editions

## Blog

- [How Rust Runs in the Browser (with wasm-bindgen)](https://belderbos.dev/blog/how-rust-runs-in-the-browser-wasm-bindgen/): I compiled my Rust JSON parser to WebAssembly in 9 lines. The interesting part is the JS glue wasm-bindgen generates, because wasm only speaks numbers.
- [ccfind: search all your Claude Code sessions](https://belderbos.dev/blog/ccfind-search-claude-code-sessions/): ccfind searches Claude Code and Codex session histories across directories, ranks matches, and gives you the command to resume a conversation.
- [My bookkeeping runs on code now. AI only reads the PDFs.](https://belderbos.dev/blog/replaced-my-bookkeeping-tool-with-python/): Where AI earned a place in my own accounting system, where it didn't, and why every row it proposes waits for a human.
- [The Programming Books I Still Recommend After 15 Years](https://belderbos.dev/blog/timeless-programming-books/): The classic software books I keep recommending, and why judgment from reading them matters more now that AI writes the first draft of your code.
- [Ship Your First Python App: a Free Course on the Local Dev Workflow](https://belderbos.dev/blog/free-python-foundations-course-local-dev-workflow/): You know Python, but the pieces around it that make a real project still confuse you. This free course teaches the local dev workflow from scratch.
- [Protocol or ABC? Designing a pluggable provider interface](https://belderbos.dev/blog/protocol-vs-abc-provider-interface/): When you need a common interface for swappable backends, the reflex is to use a good ol' abstract base class (ABC). But typing.Protocol offers a more flexible alternative.
- [Why Rust makes you import a trait to use its methods](https://belderbos.dev/blog/rust-import-traits-to-use-methods/): A Rust method only works when a seemingly unrelated trait is imported. Why is that?
- [How Libraries Run Rust Inside Python (with PyO3)](https://belderbos.dev/blog/how-libraries-run-rust-inside-python/): Build a Rust JSON parser into a module Python can import with PyO3, then see what the return trip costs when Rust data becomes Python dicts and lists.
- [Why Learn to Code If AI Can Code? 6 Reasons](https://belderbos.dev/blog/why-learn-to-code-if-ai-can-code/): Stanford's Chris Piech runs a class with 17,000 students. Enrollment basically doubled in the era of Claude Code and Cursor. Six reasons why, from his interview.
- [Database-Driven RBAC with FastAPI and Azure Entra ID](https://belderbos.dev/blog/database-driven-rbac-fastapi-azure-entra/): Wire Azure Entra ID roles into FastAPI, then keep the endpoint-to-role policy in the database so an admin can re-point access without a redeploy.
- [5 design patterns used in my new habit tracker app](https://belderbos.dev/blog/python-patterns-django-habit-tracker/): The best logic in a Django app is the code that never touches the ORM. Five small Python and design patterns from a habit tracker that keeps it decoupled.
- [Why does Alembic need an import you never use?](https://belderbos.dev/blog/what-table-true-does-sqlmodel/): That unused models import in env.py is a SQLModel metaclass side effect. The real call path from table=True down to metadata.tables in the source.
- [Unsubscribe links without a login: Django signing](https://belderbos.dev/blog/unsubscribe-without-login-django-signing/): How to build an email unsubscribe link that needs no login and no database token, using django.core.signing, and where the pattern gets dangerous.
- [Guardrails Protect Your Codebase. What Protects Your Judgment?](https://belderbos.dev/blog/ai-skill-atrophy-keep-the-friction/): AI coding erodes two different things: your skills and your code. Guardrails protect the code. Only re-deriving the hard decisions keeps your judgment sharp.
- [Learning New Skills in the AI Era (vBrownBag)](https://belderbos.dev/blog/vbrownbag-learning-skills-ai-era/): I joined the vBrownBag podcast to talk about learning new languages and skills when AI can write the code before you finish the thought.
- [Rust, AI, and the Developer Mindset (Develpreneur Podcast)](https://belderbos.dev/blog/develpreneur-podcast-rust-ai/): I joined the Develpreneur podcast with Jim Hodapp to talk about the Rust developer mindset and why the compiler is a great guardrail for AI-generated code.
- [Judgment: The Skill AI Can't Give You](https://belderbos.dev/blog/thinking-matters-more-than-ever-ai-age/): AI accelerates execution but not understanding. The developers who thrive won't be the fastest prompters. They'll be the ones who never stopped thinking.
- [One Core, Two Interfaces, No Rewrites](https://belderbos.dev/blog/two-interfaces-one-core/): The same pure functions back both a CLI and a FastAPI web app. Keep the core functional, cache the matrix, pre-warm on startup, no logic duplicated.
- [Ask the Canon: Semantic Search Without a Vector Database](https://belderbos.dev/blog/semantic-search-without-a-vector-database/): Running a semantic search over 100 classics on a droplet with embeddings, NumPy, and np.argsort. No Pinecone, no API calls at query time. Starting simple.
- [There Is No Magic: An AI Agent in 60 Lines of Python](https://belderbos.dev/blog/build-minimal-ai-agent-python/): An agent is a small amount of plumbing around a model you already understand. The whole anatomy in 60 lines of Python: model, instructions, memory, tools, loop.
- [Python Is Not Enough: Why Pythonistas Love Rust (Podcast)](https://belderbos.dev/blog/complexity-dot-fm-podcast/): I joined complexity.fm to talk about why Pythonistas are picking up Rust, what AI really does to how we learn, and why vibe coding is a myth.
- [AI Is an Accelerator, Not a Compass](https://belderbos.dev/blog/ai-accelerator-needs-direction/): AI makes you faster, but speed without direction produces three-day mistakes and dark code. Why fundamentals matter even more in 2026.
- [From Python to Rust: Master Iterators by Rebuilding 10 Unix Tools](https://belderbos.dev/blog/learn-rust-building-unix-tools/): Rebuild wc, grep, sort and sed in Rust, each exercise turning a Python idiom you know (loops, comprehensions, len) into the iterator chain you don't yet.
- [Profile First: A 10x Faster Django Test Suite](https://belderbos.dev/blog/profile-django-test-suite-10x-faster/): My Django test suite took 30 seconds. cProfile showed 83% of it was one function: password hashing. Here's how I found the bottleneck and the five-line fix.
- [End-to-End Testing Every Rust Exercise with Playwright](https://belderbos.dev/blog/playwright-e2e-testing-71-exercises/): How I use Playwright and pytest to end-to-end test every exercise on my Rust learning platform. Patterns that scale.
- [When to use classmethod, staticmethod, or instance method in Python](https://belderbos.dev/blog/classmethod-vs-staticmethod-vs-instance-method-python/): A simple decision rule for when to use a classmethod, a staticmethod, or a plain instance method in Python.
- [Building an AI Agent in 6 Weeks (and Finally Understanding How They Work)](https://belderbos.dev/blog/jeff-haemer-agentic-ai-cohort/): Jeff had decades in software but mediocre Python and no map of AI. Six weeks later: an agent with three interfaces, ~250 tests, and a real mental model.
- [Why Rust does not need OOP](https://belderbos.dev/blog/why-rust-does-not-need-oop/): Rust has no classes and no inheritance, yet it keeps the good parts of OOP. Five ways structs, traits, and ownership replace the class hierarchy.
- [AI Doesn't Change What Software Engineering Is](https://belderbos.dev/blog/ai-doesnt-change-what-software-engineering-is/): Kelsey Hightower's take on AI is the most grounded I've heard: it's a tool, and software engineering was always decision-making, not typing.
- [How to Update Multiple Page Elements from One htmx Request](https://belderbos.dev/blog/htmx-hx-swap-oob-django/): One htmx response, two updated elements. How I use hx-swap-oob to refresh a Django dropdown after a form submit, no page reload, no extra JavaScript.
- [\"Rust Is for People Who Want to Be Punished.\" Now Jochen Trusts It More Than Python.](https://belderbos.dev/blog/jochen-rust-cohort-beat-cpython/): Jochen thought Rust was self-punishment for the pros. Three months later, his hand-rolled JSON parser ran up to 3.5x faster than CPython.
- [How to Tell if Your Python Mock Is Actually Working](https://belderbos.dev/blog/python-mock-patch-verify-interception/): A test that passes because the real API returned an error is not a passing test. Here's how to verify your mock is intercepting, and fix it when it isn't.
- [Build the Simplest Thing That Works](https://belderbos.dev/blog/build-the-simplest-thing-that-works/): How constraints like 'no database' and 'two dependencies' led to a CLI CRM that fits in my head. A case for building small.
- [AI Human-in-the-loop: News Digest Triage Telegram Bot](https://belderbos.dev/blog/human-in-the-loop-telegram-bot-python/): A trend digest tells you what to read. This Telegram bot lets you tag and file each story with one tap; the human-in-the-loop pattern in less than 200 lines of Python.
- [The control layer is the product, not the model](https://belderbos.dev/blog/control-layer-is-the-product/): Gary Bernhardt called out the LLM fixation. The real work is the control layer above the model. Four patterns that make production AI reliable.
- [Learning a New Programming Language Is More Important Now, Not Less](https://belderbos.dev/blog/josh-rust-cohort-beat-cpython-json/): Everyone says AI agents make learning new languages obsolete. Josh spent six weeks learning Rust and built a JSON parser that beats CPython's C stdlib. Here's why developers who still learn languages will have the edge.
- [Two Python Scoping Bugs: A Lesson in Object Lifetimes](https://belderbos.dev/blog/two-scoping-bugs-object-lifetimes/): Two Python bugs with opposite symptoms but the same root cause: picking the wrong scope for a stateful object.
- [From Python Script to Production: A Django Coaching Case Study](https://belderbos.dev/blog/daniele-django-movie-anime-discovery/): Career changer, new to Django, built and shipped a movie and anime discovery platform in 6 weeks of 1:1 Python coaching.
- [Mind Map Your App Before You Write a Line of Code](https://belderbos.dev/blog/mind-map-software-project-scope/): Before scoping a project or writing code, spend 30-60 minutes building a mind map. This is the exercise I use with the developers I coach.
- [A 500 That Survived Ten Successful Deploys](https://belderbos.dev/blog/500-survived-ten-successful-deploys/): Page 500, clean local build, green CI. Tracing stale Cloudflare Pages state back ten releases and the lesson about silent failures.
- [What production AI agents actually require](https://belderbos.dev/blog/production-ai-agents-real-workflows/): Chatting is easy. Executing real business logic with audit trails, approvals, and rollback is where most AI agents break. Here is what to build.
- [How to Keep Your Developer Instincts When AI Writes the Code](https://belderbos.dev/blog/dont-delegate-the-friction/): AI agents will write your code if you let them. Here's the deliberate practice routine I use to stay technical when AI increasingly writes code for me.
- [10 Days of Rust for Python Developers: A Recap](https://belderbos.dev/blog/10-days-rust-python-developers-recap/): A day-by-day walkthrough of a 10-day beginner Rust challenge for Python developers. Real solution code and one idea per day that changes how you read Python.
- [Learn agentic AI in Python with 10 small exercises](https://belderbos.dev/blog/learn-agentic-ai-python-10-step-journey/): The path from a 3-line Claude call to a working agent loop. 10 patterns, one arc, runnable in your browser. No framework needed to understand what's actually happening.
- [Coding exercises that run in the browser with Pyodide](https://belderbos.dev/blog/python-exercises-browser-pyodide/): How I shipped 10 Python exercises with Anthropic SDK patterns on a static Cloudflare site. No backend, no API key, no install. Pyodide does the work.
- [A Race Condition Rust Wouldn't Have Let Me Write](https://belderbos.dev/blog/race-condition-rust-wouldnt-let-me-write/): A Python agent's module globals leaked user data between threads. The contextvars fix, plus what Rust's borrow checker would have prevented.
- [Build a daily AI digest in 200 lines of Python (no framework)](https://belderbos.dev/blog/python-ai-trend-digest-asyncio-protocol/): One Python script combines asyncio.gather, a Protocol for LLM swap, and StrEnum dispatch to fetch and rank AI news every morning.
- [The Rust Compiler as an AI Coding Agent Guardrail](https://belderbos.dev/blog/rust-compiler-ai-agent-guardrail/): Jim Hodapp and I talk about why Rust's strict compiler makes AI coding agents more reliable, and what Python developers gain from learning it.
- [Event Sourcing in Python: Get More Insights Into Your Data](https://belderbos.dev/blog/event-sourcing-python-store-events-not-state/): Event sourcing stores every change as an immutable event instead of overwriting state. Here is why that shift changes what questions your data can answer.
- [Python to Rust: A JSON Parser in 6 Weeks](https://belderbos.dev/blog/vikas-rust-cohort-ownership-pyo3/): What a senior Python engineer learned building a JSON parser from scratch in Rust.
- [Build the data layer before you touch the LLM](https://belderbos.dev/blog/build-data-layer-before-llm/): Most AI tutorials start with the API call. This one starts with a data model. Here's why, and what a proper data layer buys you in a production AI app.
- [Vibe Coding is Easy, Owning the Architecture Isn't](https://belderbos.dev/blog/vibe-coding-owning-architecture/): Generating code with AI is easy. Owning the architecture isn't. Why vibe coding creates the same trap as tutorial paralysis, and what to do instead.
- [From Hobby Code to SaaS to Orchestrating AI Agents](https://belderbos.dev/blog/ai-coding-tools-fundamentals-case-study/): Ryan Austin ships payroll software in the Bahamas. In 2021, he couldn't tell if his architecture was sound. In 2025, he's directing AI agents with confidence. The foundation made the difference.
- [How an AI expense agent is actually structured](https://belderbos.dev/blog/ai-agent-architecture-python/): LLM calls aren't magic. The four-layer architecture (Protocol, Pydantic, service layer, HITL) turns a chatbot into a production Python app.
- [Build Your First MCP Server: Code Tips in Claude and Slack](https://belderbos.dev/blog/build-mcp-server-python-tips-slack/): A step-by-step guide to building an MCP server in Python that surfaces your code tips collection inside Claude Code and a private Slack bot.
- [Stop Prompting, Start Structuring Your AI Workflow](https://belderbos.dev/blog/claude-code-skills-structured-ai-collaboration/): How I turned ad-hoc AI prompting into a repeatable coding workflow with Claude Code skills and a shared conventions file.
- [What Rust Structs Taught Me About State Ownership](https://belderbos.dev/blog/what-rust-structs-taught-me-about-state-ownership/): Rust's struct + impl separation forces you to think about state mutation in ways Python classes let you ignore. Here's what clicked.
- [Build a Finite State Machine in Python](https://belderbos.dev/blog/build-finite-state-machine-python/): Learn how finite state machines work by building one from scratch in Python. Guards, hooks, history tracking, and when to reach for a library instead.
- [How to Migrate Users Between Django Apps on Login](https://belderbos.dev/blog/login-triggered-user-migration-django/): How I migrated premium status, exercise progress, and token balances from a legacy Django app. Automatically, on first login, triggered by a Django signal.
- [From 1,069 to 156 LOC: Design Over Code](https://belderbos.dev/blog/design-over-code/): I built a 1,069-line Rust web app with AI in two sessions. Then I deleted it. The real productivity wasn't in the code, it was in the question I almost skipped.
- [How Modern Python Tooling Simplified My Setup](https://belderbos.dev/blog/modern-python-tooling-uv-ruff-ty/): uv, ruff, and ty replaced pip, venv, pyenv, black, isort, flake8, and mypy in my projects. Here's the before and after.
- [The Repository Pattern: Swap Data Sources in One Line](https://belderbos.dev/blog/repository-pattern-swappable-data-sources/): Use Python's ABC and a factory function to swap between live APIs, fake servers, and replay data without changing your app code.
- [What Building a JSON Tokenizer Taught Me About Rust](https://belderbos.dev/blog/what-building-a-json-tokenizer-taught-me-about-rust/): Learning Rust by building a JSON parser. Why a real project teaches pattern matching, state tracking, and debugging faster than exercises alone.
- [Learning Rust Made Me a Better Python Developer](https://belderbos.dev/blog/rust-made-me-a-better-python-developer/): Rust's ownership model, Result type, and exhaustive matching changed how I write Python. Here are the patterns that transferred.

## About

- [About Bob](https://belderbos.dev/about/): Background, experience, consulting and coaching approach
- [Blog](https://belderbos.dev/blog/): Articles on Python, Rust, AI, and software engineering
- [Contact](https://belderbos.dev/contact/): How to reach Bob by email, call, or inquiry form (bob@belderbos.dev)
- [Book a coaching call](https://calendly.com/bob-belderbos/chat): Call to discuss coaching goals and fit
- [Privacy notice](https://belderbos.dev/privacy/): What the site collects and why

## Developer resources

- [pybites-search](https://pypi.org/project/pybites-search/): Open-source CLI (pip install pybites-search) to search Pybites articles, tips, and exercises from the terminal; source at https://github.com/bbelderbos/pybites-search
- [sitemap.xml](https://belderbos.dev/sitemap.xml): Machine-readable index of every URL on the site

## Optional

- [Pybites Platform](https://pybitesplatform.com): Interactive Python exercise platform with 435 exercises
- [Rust Platform](https://rustplatform.com): Hands-on Rust exercises for Pythonistas
- [Pybites Books](https://pybitesbooks.com): Privacy-respecting reading tracker for developers