# Mike Bild > Software architect & engineer in Berlin. More than 30 years of software, a good 15 of them focused on distributed systems, APIs and digital products. These days also agentic engineering. ## Navigation - [Profile](https://www.mikebild.dev/en/profile/) - [Blog](https://www.mikebild.dev/en/blog/) - [Projects](https://www.mikebild.dev/en/projects/) - [Contact](https://www.mikebild.dev/en/contact/): mike.bild@gmail.com - [GitHub](https://github.com/MikeBild) - [LinkedIn](https://www.linkedin.com/in/mikebild) - [Mike Bild · Blog](https://www.mikebild.dev/en/feed.xml) - [Mike Bild · Blogcast](https://www.mikebild.dev/de/blogcast.xml): Selected blog articles by Mike Bild as audio versions – software architecture, engineering and method. - [MCP knowledge server](https://worker.mikebild.dev/workshop-online-api/knowledge/mcp): Articles, slide decks and the workshop catalog for AI assistants, read-only, no login. Guide: https://www.mikebild.dev/en/mcp/ - [Deutsch](https://www.mikebild.dev/llms.txt) ## Current projects - [SubKit](https://subkit.mikebild.dev/en/): Built once with the AI, shared by approval: team workflows with permissions and history. (Beta by invitation) - [Harmoniqs](https://harmoniqs.mikebild.dev/en/): Develop song ideas with chords, the Looper and BRAIN. (Beta) - TackTics: A sailing trainer meant to analyze data from on board. (In progress) ## Training - [JavaScript and TypeScript from scratch](https://slides.mikebild.dev/introduction-javascript-typescript.en.html): You write modern JavaScript and type it with TypeScript so the compiler finds your mistakes before deployment. – Repository: https://github.com/MikeBild/introduction-javascript – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-javascript-typescript/introduction-javascript-typescript.en.pdf?v=7c3d048ab16c – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-javascript-typescript/introduction-javascript-typescript.en.mp4?v=7c3d048ab16c – Deutsch: https://slides.mikebild.dev/introduction-javascript-typescript.html - [Python for developers with uv, pytest, and Flask](https://slides.mikebild.dev/introduction-python.en.html): You learn modern Python with uv, type hints, and pytest, and build a tested HTTP API with Flask for the workshop shop. – Repository: https://github.com/MikeBild/introduction-python – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-python/introduction-python.en.pdf?v=a9426e4ffd37 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-python/introduction-python.en.mp4?v=a9426e4ffd37 – Deutsch: https://slides.mikebild.dev/introduction-python.html - [Modern web platform without a framework](https://slides.mikebild.dev/introduction-web-plattform.en.html): You build the workshop shop using only the browser’s HTML, CSS, and JavaScript: accessible, fast, offline-capable, and with Web Components. – Repository: https://github.com/MikeBild/introduction-web-plattform – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-web-plattform/introduction-web-plattform.en.pdf?v=a8018c5e80c1 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-web-plattform/introduction-web-plattform.en.mp4?v=a8018c5e80c1 – Deutsch: https://slides.mikebild.dev/introduction-web-plattform.html - [Node.js backend, functional and type-safe](https://slides.mikebild.dev/introduction-nodejs.en.html): You build a Node.js service with Express 5 from the first request to container operations, tested, logged, and hardened. – Repository: https://github.com/MikeBild/introduction-nodejs – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-nodejs/introduction-nodejs.en.pdf?v=965710139dd0 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-nodejs/introduction-nodejs.en.mp4?v=965710139dd0 – Deutsch: https://slides.mikebild.dev/introduction-nodejs.html - [React with TypeScript all the way to production](https://slides.mikebild.dev/introduction-react.en.html): You use React, TypeScript, and React Router to build an app from small components, then ship it to production with tests and good accessibility. – Repository: https://github.com/MikeBild/introduction-react – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-react/introduction-react.en.pdf?v=19f0d4ba8526 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-react/introduction-react.en.mp4?v=19f0d4ba8526 – Deutsch: https://slides.mikebild.dev/introduction-react.html - [Svelte 5 and SvelteKit with TypeScript](https://slides.mikebild.dev/introduction-svelte.en.html): You build the workshop store with Svelte 5, runes, and SvelteKit 3, from the first component to a tested Node server. – Repository: https://github.com/MikeBild/introduction-svelte – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-svelte/introduction-svelte.en.pdf?v=8ed6ed7c9262 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-svelte/introduction-svelte.en.mp4?v=8ed6ed7c9262 – Deutsch: https://slides.mikebild.dev/introduction-svelte.html - [Modernize KnockoutJS and migrate step by step](https://slides.mikebild.dev/introduction-knockoutjs.en.html): You maintain a Knockout application with TypeScript, Vite, and tests, close security gaps, and plan the migration in small steps. – Repository: https://github.com/MikeBild/introduction-knockoutjs – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-knockoutjs/introduction-knockoutjs.en.pdf?v=db3087c1f285 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-knockoutjs/introduction-knockoutjs.en.mp4?v=db3087c1f285 – Deutsch: https://slides.mikebild.dev/introduction-knockoutjs.html - [GraphQL from schema to production](https://slides.mikebild.dev/introduction-graphql.en.html): You build a GraphQL API with Apollo, from the first schema to a public graph that limits cost and can evolve safely. – Repository: https://github.com/MikeBild/introduction-graphql – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-graphql/introduction-graphql.en.pdf?v=a1a1bae43fe5 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-graphql/introduction-graphql.en.mp4?v=a1a1bae43fe5 – Deutsch: https://slides.mikebild.dev/introduction-graphql.html - [Reactive programming with RxJS](https://slides.mikebild.dev/introduction-reactive-programming.en.html): You describe search, live status, and user input as streams with RxJS and test time-dependent code without real waiting time. – Repository: https://github.com/MikeBild/Reactive-Programming – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-reactive-programming/introduction-reactive-programming.en.pdf?v=51202b99fbfc – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-reactive-programming/introduction-reactive-programming.en.mp4?v=51202b99fbfc – Deutsch: https://slides.mikebild.dev/introduction-reactive-programming.html - [Docker & Kubernetes](https://slides.mikebild.dev/introduction-docker-kubernetes.en.html): You put the workshop shop API into containers and run it in Kubernetes: from image and Compose to rollout, Gateway API, and hardening. – Repository: https://github.com/MikeBild/introduction-docker – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-docker-kubernetes/introduction-docker-kubernetes.en.pdf?v=dcfe9fd4c4f6 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-docker-kubernetes/introduction-docker-kubernetes.en.mp4?v=dcfe9fd4c4f6 – Deutsch: https://slides.mikebild.dev/introduction-docker-kubernetes.html - [AWS serverless with Lambda, CDK, and DynamoDB](https://slides.mikebild.dev/introduction-aws-serverless.en.html): You build the workshop shop order flow serverless on AWS, with Lambda, DynamoDB, events, and Step Functions, all as code in CDK. – Repository: https://github.com/MikeBild/introduction-aws – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-aws-serverless/introduction-aws-serverless.en.pdf?v=686d760b188f – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-aws-serverless/introduction-aws-serverless.en.mp4?v=686d760b188f – Deutsch: https://slides.mikebild.dev/introduction-aws-serverless.html - [Microservices with Node.js, Express 5, and Docker Compose](https://slides.mikebild.dev/introduction-microservices.en.html): You split the workshop shop into services along domain boundaries and connect them with contracts, events, outbox, and sagas. – Repository: https://github.com/MikeBild/introduction-microservices – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-microservices/introduction-microservices.en.pdf?v=755b9c76bf78 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-microservices/introduction-microservices.en.mp4?v=755b9c76bf78 – Deutsch: https://slides.mikebild.dev/introduction-microservices.html - [Design patterns as functions](https://slides.mikebild.dev/introduction-design-patterns.en.html): You solve recurring problems in the workshop shop with design patterns as functions and recognize them again in Express, React, and Apollo. – Repository: https://github.com/MikeBild/introduction-design-patterns – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-design-patterns/introduction-design-patterns.en.pdf?v=d9e4820e2aef – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-design-patterns/introduction-design-patterns.en.mp4?v=d9e4820e2aef – Deutsch: https://slides.mikebild.dev/introduction-design-patterns.html - [Architecture: DDD, CQRS, and Event Sourcing](https://slides.mikebild.dev/introduction-cqrs-event-sourcing.en.html): You model the workshop shop with DDD, separate writes and reads with CQRS, and store orders as events, only where it pays off. – Repository: https://github.com/MikeBild/introduction-nodejs/tree/master/EXAMPLES/ARCHITECTURE – PDF: https://media.mikebild.dev/site/mikebild/decks/introduction-cqrs-event-sourcing/introduction-cqrs-event-sourcing.en.pdf?v=d420df81ac12 – Video: https://media.mikebild.dev/site/mikebild/decks/introduction-cqrs-event-sourcing/introduction-cqrs-event-sourcing.en.mp4?v=d420df81ac12 – Deutsch: https://slides.mikebild.dev/introduction-cqrs-event-sourcing.html ## Blog - [Interim Review and System View: Taking Stock of the Series](https://www.mikebild.dev/en/blog/interim-review-and-system-view/): Months after the conversation where it all began, it’s time for an honest assessment: which expectations from the opening came true, which didn’t, what remains open – and why the most exciting question is no longer what the models can do, but what organizations make of it. - [MCP, HTTP, Webhooks and A2A Explained Simply](https://www.mikebild.dev/en/blog/mcp-http-webhooks-and-a2a-explained-simply/): MCP, HTTP with OpenAPI, webhooks and A2A connect systems at different levels. What matters is which responsibility lies at each boundary. - [A2A: When Agents Work Together](https://www.mikebild.dev/en/blog/a2a-when-agents-work-together/): Agent Card, Message, Task and Artifact explained clearly: how A2A 1.0 connects independent agent systems, what sets the protocol apart from MCP and when delegating to an independent system pays off. - [Hourly Is Not Real Time](https://www.mikebild.dev/en/blog/hourly-is-not-real-time/): A closed hourly report answers different questions than ongoing operational monitoring – and gets simpler as soon as time windows, delays and measurement gaps are modeled explicitly. - [Claims: Small, Sourced, Verifiable](https://www.mikebild.dev/en/blog/claims-small-sourced-verifiable/): Claims break wiki pages down into individual statements with subject, predicate, object, confidence, status and a verbatim quote as evidence. This makes agreement and disagreement precise. - [Products Report Through Their API](https://www.mikebild.dev/en/blog/products-report-through-their-api/): Product statistics stay understandable when every system aggregates its own data and offers it through a small HTTP contract with uniform time semantics. - [From Org Chart to Product Ownership](https://www.mikebild.dev/en/blog/from-org-chart-to-product-ownership/): AI makes the path from customer problem to impact more continuous. - [llms.txt: Docs for Machines](https://www.mikebild.dev/en/blog/llms-txt-docs-for-machines/): Context for models, not for ranking: why llms.txt and llms-full.txt help coding agents – and what an MCP server makes of them. - [Tools That Hold Up: Concepts, Methods, Processes](https://www.mikebild.dev/en/blog/tools-that-hold-up-concepts-methods-processes-article/): You cannot install an agent for your own domain – but you can very well learn the way there. Which concepts hold up, which methods keep the start small and which processes keep rules from going stale. - [AI Agents per Domain: Rules, Approvals and Evidence](https://www.mikebild.dev/en/blog/ai-agents-per-domain/): How an AI agent enforces domain rules across several tool calls: with case state, checked plans, approvals and traceable execution. - [MCP Security: Tools, Permissions and Approvals for AI Agents](https://www.mikebild.dev/en/blog/mcp-security-tools-permissions-and-approvals/): How to integrate MCP tools into applications safely: server-side permission checks, human approvals, protection against prompt injection and traceable calls. - [Agent, Model, Domain](https://www.mikebild.dev/en/blog/agent-model-domain/): The model is rented, the agent can be under your own control – what matters is whether the domain lives as prose in the prompt or as a checked interface in the agent. - [Knowledge That Survives the Session](https://www.mikebild.dev/en/blog/knowledge-that-survives-the-session/): Session knowledge evaporates when no one curates it – why teams should treat their AI working knowledge like code, and why it’s not the model that gets smarter but the organization that learns. - [Clean Grounding II: Grounding Answers](https://www.mikebild.dev/en/blog/clean-grounding-ii-grounding-answers/): My working model for grounding distinguishes conventions, documents and API descriptions. What stays in the scarce context, I prioritize by task and by the cost of fetching it again. - [AI in the Enterprise: Faster Development Needs Different Processes](https://www.mikebild.dev/en/blog/ai-in-the-enterprise-faster-development-different-processes/): AI shortens research, design and implementation. If handoffs, ticket hierarchies and approvals stay the same, the bottleneck just moves – so large companies have to rethink workflow and governance together. - [Clean Grounding I: Why AI Guesses So Convincingly](https://www.mikebild.dev/en/blog/clean-grounding-i-why-ai-guesses-so-convincingly/): Why language models invent plausible things, why more training doesn’t reliably eliminate the problem and what grounding has to do with it. - [My Success Cannot Be Copied](https://www.mikebild.dev/en/blog/my-success-cannot-be-copied/): A colleague takes over my AI setup and gets different results. Tools, tests and conventions can be transferred; how you cut tasks, how you review and the course of an individual session only to a limited degree. - [What I Am Critical Of](https://www.mikebild.dev/en/blog/what-i-am-critical-of/): Four observations and one open hypothesis after intense months with AI – from a possible loss of skills to the worry about more uniform solutions, and my practical countermeasures. - [Good Enough: The Model Is Rarely the Bottleneck](https://www.mikebild.dev/en/blog/good-enough-models/): For the everyday tasks I work on with AI myself, the choice of model is rarely the first bottleneck. How the task is cut, the context and the verification usually matter more. - [From Tool to Way of Working](https://www.mikebild.dev/en/blog/from-tool-to-way-of-working/): How a conversation in Berlin, after more than thirty years of software craftsmanship, got me working daily with Claude, ChatGPT and Claude Code – and why I still distrust my own enthusiasm for now. - [React Overview: From JSX to Component Architecture](https://www.mikebild.dev/en/blog/react-overview-from-jsx-to-component-architecture/): A complete walk through React the way I teach it today – from declarative rendering through the question of who owns a piece of state to the architecture of a growing application. The details of individual stops will follow later as separate posts. - [Forms in React 19: Actions, useActionState and useOptimistic](https://www.mikebild.dev/en/blog/forms-in-react-19-with-actions/): React 19 makes the form the actual interface: a function as the form action, plus three hooks for the result, the pending state and instant UI feedback. This post shows how they work together – and where optimistic rendering breaks down without a clean error path. - [React Server Components and Server Actions: The New Boundary](https://www.mikebild.dev/en/blog/react-server-components-and-server-actions/): Server Components run outside the client bundle and send their result to the browser instead of their code. Server Functions move writes to the server – both are implemented by a suitable framework or bundler. - [React Router Data Router: The URL as the Place for State](https://www.mikebild.dev/en/blog/react-router-data-router-the-url-as-state/): The data router in React Router makes the URL the point of coordination – a route loads its data via loader before rendering and writes via action, so loading logic disappears from the component body. - [React Transitions: Non-Urgent Updates with useTransition](https://www.mikebild.dev/en/blog/react-transitions-with-usetransition/): useTransition marks updates as non-urgent and keeps React responsive during expensive or suspending renders. Plus useDeferredValue as the tool for downstream renders. - [React Testing Without Theater](https://www.mikebild.dev/en/blog/react-testing-without-theater/): Tests tied to visible user behavior are less coupled to DOM structure, component boundaries and internal state. As a result, they survive certain refactorings without changes. - [Suspense and the use Hook: Rendering as If the Data Were Already There](https://www.mikebild.dev/en/blog/suspense-and-the-use-hook/): Instead of managing a loading state in every component, Suspense lets you describe in a single place in the tree what appears while waiting – and the use hook lets the component below render as if the data had long arrived. - [Client State vs. Server Cache: The Most Consequential Boundary in the Frontend](https://www.mikebild.dev/en/blog/client-state-vs-server-cache/): Server data is state, but not client-owned state. Why this distinction matters, when useEffect turns into a bad cache and what a server state library takes over. - [Testing Schedulers and Virtual Time](https://www.mikebild.dev/en/blog/testing-schedulers-and-virtual-time/): Injectable time makes time-dependent rules testable quickly and deterministically. Data, isolation and external systems remain unaffected by it. - [GraphQL Overview: From Schema to Federated API](https://www.mikebild.dev/en/blog/graphql-overview-from-schema-to-federated-api/): A walk through GraphQL – from the typed schema through queries and resolvers to real time, operations and federated architecture, assessed as of October 2024. - [HTTP/2 and Server-Sent Events in Node.js](https://www.mikebild.dev/en/blog/http2-and-server-sent-events-in-nodejs/): How HTTP/2 multiplexes many streams over one connection and why Server-Sent Events are often a simpler answer to live data than WebSocket – with a working SSE endpoint in Node and the usual pitfalls. - [Markdown Reports Instead of Dashboard Mandates](https://www.mikebild.dev/en/blog/markdown-reports-instead-of-dashboards/): Why a diffable Markdown report often does more for traceability, review and operations than a dashboard – and how I set that up architecturally. - [GraphQL Federation: One Schema from Many Subgraphs](https://www.mikebild.dev/en/blog/graphql-federation-and-subgraphs/): When one team can no longer carry a monolithic schema on its own, Federation splits the graph into subgraphs that a router composes into a supergraph. Using a users and orders example, this article shows how @key and __resolveReference hold entities together across subgraph boundaries. - [Fuzzy Matching with Explicit Limits](https://www.mikebild.dev/en/blog/fuzzy-matching-with-explicit-limits/): A fuzzy match is a claim with a confidence, not a fact – it only becomes useful through versioned thresholds, three decision zones, and a diffable report of the gray zone. - [Event Sourcing on AWS: DynamoDB Streams and Lambda](https://www.mikebild.dev/en/blog/event-sourcing-on-aws-dynamodb-streams-and-lambda/): Event Sourcing implemented serverless: DynamoDB as an append-only event store, DynamoDB Streams as the change feed and Lambda as an idempotent projector into CQRS read models. - [Testing RxJS with Marble Diagrams](https://www.mikebild.dev/en/blog/testing-rxjs-with-marble-diagrams/): Marble diagrams make the timing of asynchronous streams visible. With TestScheduler.run and virtual time, you test RxJS operators deterministically: no real waiting, no flakiness. - [Invoice Data as a Domain](https://www.mikebild.dev/en/blog/invoice-data-as-a-domain/): Why an invoice import isn’t a CSV job but a domain with its own terms, invariants and time rules – and how explicit types and a rejection report turn silent data errors into explainable data. - [Testing Node.js: The Test Pyramid with Mocha](https://www.mikebild.dev/en/blog/testing-nodejs-the-test-pyramid-with-mocha/): How to distribute a Node.js test suite sensibly across different test levels and how Mocha, node:assert, sinon and supertest work together along the way. - [Deterministic CLIs](https://www.mikebild.dev/en/blog/deterministic-clis/): Determinism is an architecture decision: same inputs, same report, reviewable via diff. It pays off wherever an artifact is checked repeatedly. - [Observability with OpenTelemetry: Logs, Traces and Metrics](https://www.mikebild.dev/en/blog/observability-with-opentelemetry/): Instrument logs, traces and metrics consistently with OpenTelemetry, connect them through trace IDs and export them via OTLP to suitable backends. - [The GraphQL Client: Apollo Link and Fragments](https://www.mikebild.dev/en/blog/graphql-client-apollo-link-and-fragments/): Apollo Link runs every GraphQL operation through a chain of middleware: authLink sets headers, errorLink handles errors in one place, split routes subscriptions. Plus fragments as reusable field sets and why interfaces need possibleTypes. - [OCR with a Cache and Distrust](https://www.mikebild.dev/en/blog/ocr-with-a-cache-and-distrust/): Why an OCR pipeline for receipt data only feels reliable once you secure every recognized value with a hash cache, a confidence gate and plausibility rules instead of believing it. - [The Four Subject Types in RxJS](https://www.mikebild.dev/en/blog/the-four-subject-types-in-rxjs/): Subject, BehaviorSubject, ReplaySubject and AsyncSubject differ in what late subscribers see and in how completion or an error ends their stored behavior. - [Apollo Client: The Normalized Cache and Optimistic Updates](https://www.mikebild.dev/en/blog/apollo-client-normalized-cache-and-optimistic-updates/): HTTP caching is possible with GraphQL too, but for client state it is often less direct. That is why Apollo normalizes objects and supports optimistic updates in the UI. - [Securing GraphQL: Query Depth, Complexity and Rate Limiting](https://www.mikebild.dev/en/blog/securing-graphql-depth-complexity-rate-limiting/): A single GraphQL endpoint accepts arbitrarily nested queries – convenient and at the same time a risk of abuse. I show how I build a layered defense against expensive queries with a depth limit, a complexity budget, pagination caps and rate limiting. - [TypeScript in Node.js: Setup, Types and Tests](https://www.mikebild.dev/en/blog/typescript-in-nodejs/): Setting up TypeScript in a Node project: understand the tsconfig essentials, type async code and handlers, and get the tests running, step by step from project practice. - [TypeScript in React: Typing Props, Hooks and Events](https://www.mikebild.dev/en/blog/typescript-in-react/): How props and state become verifiable contracts – and your editor reports errors before your users see them. From interface/type through useState generics and event types to useRef and utility types. - [Resilience Patterns: Timeout, Retry, Circuit Breaker, Idempotency](https://www.mikebild.dev/en/blog/resilience-patterns-timeout-retry-circuit-breaker/): Why resilience is no accident: timeout, retry with backoff and jitter, circuit breaker and idempotency as deliberately designed patterns against the failure modes of distributed systems. - [GraphQL Subscriptions over SSE: Real Time Without Being Forced into WebSocket](https://www.mikebild.dev/en/blog/graphql-subscriptions-over-sse/): Subscriptions don’t need a WebSocket. Server-Sent Events are enough for the one-way server-to-client channel, while queries and mutations stay plain HTTP, and the schema decides what counts as a domain event in the first place. - [Contract Testing Instead of an E2E Marathon](https://www.mikebild.dev/en/blog/contract-testing-instead-of-an-e2e-marathon/): Consumer-Driven Contracts check interfaces at the boundary between services instead of in an expensive, flaky end-to-end suite. The result: a faster, deterministic deploy gate and teams that release independently. - [Errors as Architecture in Node.js: Safety Nets Against the Crash](https://www.mikebild.dev/en/blog/errors-as-architecture-in-nodejs/): Error handling in Node.js is not try/catch cosmetics but a decision about levels, escalation and orderly termination. If you know the four error levels and take graceful shutdown seriously, you build services that die in a controlled way instead of running on in a corrupt state. - [DORA Metrics: What Really Shortens Development Cycles](https://www.mikebild.dev/en/blog/dora-metrics-what-really-shortens-cycles/): Lead time, deploy frequency, change fail rate, and recovery time are diagnostic values, not vanity velocity. They show where the cycle gets stuck – and why speed and stability don’t have to be opposites. - [child_process in Node.js: Scaling Without Illusions](https://www.mikebild.dev/en/blog/child-process-in-nodejs-scaling-without-illusions/): Node.js runs on a single event loop – CPU work blocks everything. This post shows when fork, cluster, and worker_threads really help and when they are just overhead. - [Understanding Lambda Performance and Cold Starts](https://www.mikebild.dev/en/blog/understanding-lambda-performance-and-cold-starts/): What a cold start in AWS Lambda really is, which levers you control – from bundle size through init code and memory to Provisioned Concurrency – and how to measure all of it properly. - [RxJS in Node.js: Processing Event Streams Reactively](https://www.mikebild.dev/en/blog/rxjs-in-nodejs-event-streams/): RxJS in Node.js: how fromEvent turns an EventEmitter into an observable, how operators transform server-side streams declaratively and why RxJS has no real backpressure. - [Evolutionary Architecture: Systems That Are Allowed to Change](https://www.mikebild.dev/en/blog/evolutionary-architecture-systems-allowed-to-change/): Architecture is not an end state that you lock down once. Small changes and suitable fitness functions make selected risks visible earlier, but they guarantee neither speed nor quality. - [From HOCs and Render Props to Custom Hooks](https://www.mikebild.dev/en/blog/from-hocs-and-render-props-to-custom-hooks/): How do I share logic between components without copy-paste? Custom hooks usually avoid nested wrappers for this; HOCs and render props keep a few specific composition tasks. - [Async Context in Node.js: AsyncLocalStorage, async_hooks and diagnostics_channel](https://www.mikebild.dev/en/blog/async-context-in-nodejs-with-asynclocalstorage/): How to carry request-scoped context such as request ID, user and trace through deep asynchronous call chains without threading it through every function signature – with AsyncLocalStorage, the underlying async_hooks and diagnostics_channel for decoupled tracing. - [GraphQL Auth: Identity in the Context, Authorization in the Domain Logic](https://www.mikebild.dev/en/blog/graphql-auth-identity-in-the-context/): The GraphQL context carries the identity of a request. Whether that identity may perform an operation is decided by a central policy in the domain logic. - [Debugging and Profiling Node.js Locally](https://www.mikebild.dev/en/blog/debugging-and-profiling-nodejs-locally/): From the console.log reflex to the built-in inspector: node --inspect, the debug module, nodemon and first CPU and memory profiles for local diagnosis. - [Developer Productivity: Shorter Cycles with High Quality](https://www.mikebild.dev/en/blog/developer-productivity-shorter-cycles/): Short feedback loops with reliable quality are my mental model for developer productivity. Where the waiting actually happens has to be shown by your own lead time. - [Slots, Context and Web Components in Svelte](https://www.mikebild.dev/en/blog/slots-context-and-web-components-in-svelte/): Three composition tools in Svelte 3: slots pass content in from the outside, the Context API avoids prop drilling, and custom elements make a component reusable independently of any framework. - [Build vs. Runtime in Web Projects](https://www.mikebild.dev/en/blog/build-vs-runtime-in-web-projects/): The rendering time is decided per route. Static, dynamic and incremental models can be combined according to data shelf life, cost and failure behavior. - [Streams in Object Mode: Data Pipelines Beyond Bytes](https://www.mikebild.dev/en/blog/streams-in-object-mode/): Node.js streams carry more than bytes: with objectMode:true they become composable data pipelines that parse, filter and aggregate – including the bridge to async iterators. - [Reproducible Test Pipelines: No Flakiness, No Chance](https://www.mikebild.dev/en/blog/reproducible-test-pipelines/): Flakiness points to uncontrolled inputs or dependencies. If you make time, data and isolation visible, you can narrow down the cause and make the merge gate trustworthy again. - [Adapter Design: Where Frameworks End](https://www.mikebild.dev/en/blog/adapter-design-where-frameworks-end/): What a framework adapter really does: the contract over the build output, the translation of request and response, and the silent environment assumptions at the boundary between SvelteKit and AWS. - [RxJS in React: Observables in the UI Data Flow](https://www.mikebild.dev/en/blog/rxjs-in-react-observables-in-the-ui-data-flow/): RxJS does not shine everywhere in React, only where asynchronous events have to be coordinated – debounced input, canceled autocomplete requests, continuous streams. The post shows the few places where observables really pay off, and where useState is perfectly enough. - [Motion, Transitions and Animations in Svelte](https://www.mikebild.dev/en/blog/motion-transitions-and-animations-in-svelte/): How Svelte ships motion declaratively and without an extra library: transition directives for fading in and out, svelte/motion for smoothly interpolated values and animate:flip for reordering lists. - [Buffers in Node.js: Working with Binary Data](https://www.mikebild.dev/en/blog/buffers-in-nodejs-working-with-binary-data/): Why JS strings don’t work for raw bytes and Buffer is Node’s tool for them: alloc versus allocUnsafe, reading and writing encodings cleanly, and the memory trap behind slice and subarray. - [Svelte Stores: State Outside the Component](https://www.mikebild.dev/en/blog/svelte-stores-state-outside-the-component/): Svelte stores are a minimal model for state that doesn’t fit into a single component: writable, readable, derived – plus the $ shorthand that subscribes and cleans up on unmount. - [Node.js Streams: Understanding and Using Backpressure](https://www.mikebild.dev/en/blog/nodejs-streams-understanding-backpressure/): Why a fast producer must not overrun a slow consumer – and how pipe, pipeline, the return value of write() and the drain event handle flow control in Node.js. - [Fitness Functions: Checking Selected Architecture Properties](https://www.mikebild.dev/en/blog/fitness-functions-checking-architecture-properties/): Fitness functions make selected properties such as coupling, dependencies and latency continuously checkable. They don’t replace domain quality or architectural trade-offs. - [Svelte Reactivity: The Compiler Instead of a Virtual DOM](https://www.mikebild.dev/en/blog/svelte-reactivity-the-compiler-instead-of-a-virtual-dom/): Svelte compiles components at build time into targeted DOM code instead of diffing a virtual DOM at runtime. I show the mental model, reactive assignment with $: and the classic push trap that I keep running into in projects. - [EventEmitter: The Event Model at the Core of Node.js](https://www.mikebild.dev/en/blog/eventemitter-the-event-model-at-the-core-of-nodejs/): EventEmitter is the common denominator beneath streams, HTTP servers and processes: I show on/once/off/emit, the special behavior of 'error' and how to avoid listener leaks. - [GraphQL Pagination: Cursors, Connections and the Relay Pattern](https://www.mikebild.dev/en/blog/graphql-pagination-cursors-and-connections/): Why offset/limit produces duplicates and gaps in changing lists, and how cursor-based pagination with the connections pattern stays stable – including the schema, a resolver sketch and the pitfalls from real projects. - [SvelteKit Adapter AWS: Framework Meets Cloud](https://www.mikebild.dev/en/blog/sveltekit-adapter-aws-framework-meets-cloud/): Why I built my own SvelteKit adapter for AWS and what the translation between the framework build and Lambda, S3 and CloudFront reveals about both sides. - [Preview Environments per Pull Request](https://www.mikebild.dev/en/blog/preview-environments-per-pull-request/): Ephemeral environments per pull request shorten feedback and make reviews concrete: you click through the change instead of imagining it from the diff. - [Jamstack as an Architecture Style for Web Applications](https://www.mikebild.dev/en/blog/jamstack-as-an-architecture-style/): Jamstack describes an architecture style with a pre-rendered frontend and decoupled services. This post puts the original building blocks JavaScript, APIs and Markup into context as of 2021. - [Serverless Transactional Email: SES and Lambda](https://www.mikebild.dev/en/blog/serverless-transactional-email-with-ses-and-lambda/): How SES becomes an event-driven email building block: outgoing confirmation emails from a Lambda Function and incoming Receipt Rules that turn an email into a handler call. - [State Management in React: Redux Toolkit, Lightweight Stores, MobX](https://www.mikebild.dev/en/blog/state-management-in-react/): When state is truly app-wide, the tool question comes up – Redux Toolkit, a lightweight store such as Zustand or Jotai, or the reactive model of MobX. But why this choice only comes after the counter-check, and usually turns out smaller than expected. - [DynamoDB Data Modeling: Single-Table Design](https://www.mikebild.dev/en/blog/dynamodb-data-modeling-single-table-design/): DynamoDB rewards a different way of thinking than a relational database: not starting from the data model but from the access patterns. Single-table design combines several entity types in one table through composite keys. - [CDN Construct: A Small Infrastructure API](https://www.mikebild.dev/en/blog/cdn-construct-a-small-infrastructure-api/): Why a custom CDK construct for static websites is more than saved lines: an opinionated interface over S3, CloudFront, certificates and DNS. - [Outcome Before Output: Why Velocity Is the Wrong Number](https://www.mikebild.dev/en/blog/outcome-before-output/): Completed tickets are output, but not yet evidence of impact. Why velocity misleads in management reporting and how to align teams with outcomes instead. - [Data Analysis with NumPy, Pandas, and Matplotlib](https://www.mikebild.dev/en/blog/data-analysis-with-numpy-pandas-and-matplotlib/): From raw data to insight: how NumPy, pandas, and Matplotlib work together – vectorized computation, groupby aggregation, and a quick plot in a small pipeline. - [When CQRS and Event Sourcing Are Too Much](https://www.mikebild.dev/en/blog/when-cqrs-and-event-sourcing-are-too-much/): For most systems, CRUD is enough. CQRS and Event Sourcing only pay off under clear conditions – this article offers an honest decision guide instead of patterns for their own sake. - [GraphQL Concepts: Schema, Resolvers, Execution](https://www.mikebild.dev/en/blog/graphql-concepts-schema-resolvers-execution/): The ideas behind GraphQL that last, no matter which server is in fashion right now – the schema as a typed contract, the query as a shape, the resolver model and the order of execution. A conceptual deep dive with diagrams. - [GraphQL APIs with AppSync and DynamoDB](https://www.mikebild.dev/en/blog/graphql-apis-with-appsync-and-dynamodb/): AWS AppSync moves the GraphQL server out of your own operational responsibility and into a managed service. Using a DynamoDB backend, I show when this build-vs-buy decision holds up and when managed becomes a dead end, including the VTL mapping templates that are the price for it in 2021. - [Using Context Well: A Distribution Path, Not Secret Global State](https://www.mikebild.dev/en/blog/using-react-context-well/): Context solves distributing data through the tree – but not the question of who owns the state. If you confuse the two, you build a global store through the back door and cause unnecessary renders when provider values change carelessly. - [Reading Data in Python: CSV, JSON, Excel and Databases](https://www.mikebild.dev/en/blog/reading-data-in-python/): A toolkit for every data source: when the standard library is enough, when pandas pays off, and how to keep encoding, memory and SQL injection from becoming your downfall. - [Architecture Decision Records: Decisions You Will Still Understand in Two Years](https://www.mikebild.dev/en/blog/adrs-decisions-you-still-understand/): Why did we choose PostgreSQL back then and decide against the message bus? ADRs make the why durable as a versioned Markdown artifact – instead of letting it seep away in hallway talk. - [A GraphQL Schema That Grows: Evolution Without Breakage](https://www.mikebild.dev/en/blog/a-graphql-schema-that-grows/): How to evolve a GraphQL schema additively instead of versioning it – safe changes, real breaking changes, @deprecated as a tool and a field migration step by step. - [Serverless Workflows with AWS Step Functions](https://www.mikebild.dev/en/blog/serverless-workflows-with-aws-step-functions/): Step Functions turn nested Lambda handlers into a declarative state machine: a visible flow, explicit retry and catch paths, Standard or Express. - [Event Sourcing: The Event Store as a Logbook](https://www.mikebild.dev/en/blog/event-sourcing-the-event-store-as-a-logbook/): Event Sourcing doesn’t store the current state but the sequence of events as the source of truth: the event store as a logbook, the state as the result of a fold. Benefits, honest costs and how it differs from CQRS. - [Testing Flask Apps: The Test Client and Reliable Endpoints](https://www.mikebild.dev/en/blog/testing-flask-apps/): How I test Flask endpoints: with app.test_client() without a running server, pytest fixtures and verified JSON responses. - [Preserving and Resetting State: React and the Position in the Tree](https://www.mikebild.dev/en/blog/preserving-and-resetting-state-in-react/): React does not store state in the component but at its position in the render tree – once you understand that, you control preservation and reset on purpose instead of by accident. - [Serverless Auth with Cognito User Pools](https://www.mikebild.dev/en/blog/serverless-auth-with-cognito-user-pools/): Cognito User Pools as a managed identity backend: sign-up, confirm and sign-in without your own auth server, the three tokens properly understood, and an API Gateway endpoint secured by a Cognito authorizer. - [Trunk-Based Development Instead of a Branch Graveyard](https://www.mikebild.dev/en/blog/trunk-based-development-instead-of-a-branch-graveyard/): Short integration cycles with feature flags beat long-lived branches: daily integration without merge hell and a release that becomes a decision instead of a deploy event. - [How React Renders and Updates the Tree](https://www.mikebild.dev/en/blog/how-react-renders-and-updates-the-tree/): From the JSX element to the visible pixel – what exactly happens between a state change and the redrawn screen. Render and commit as separate phases, the comparison of two trees and why React almost always touches only a tiny part of the DOM. - [Team Automation with GitHub Actions](https://www.mikebild.dev/en/blog/team-automation-with-github-actions/): Why I run selected, recurring checks as workflows – and how you can tell whether the automation actually takes load off the team. - [Web APIs with Flask: From the App to a JSON API](https://www.mikebild.dev/en/blog/web-apis-with-flask/): From Hello World to a JSON API: how routing, request handling and jsonify work together in Flask 1.1 – and why SSR and APIs are the same mechanism. - [Read Models from Events: Projections Instead of Accidental Caches](https://www.mikebild.dev/en/blog/read-models-from-events-projections/): A read model built from events is a deliberately maintained projection for concrete queries. Origin and rebuild set it apart from an accidentally grown cache, even if the technical view can look cache-like. - [Cloud Guardrails Instead of Cloud Gatekeeping](https://www.mikebild.dev/en/blog/cloud-guardrails/): Why central approval processes in the cloud breed shadow infrastructure and how technically enforced guardrails – SCPs, Permission Boundaries, Config Rules, budgets – give teams their freedom of movement back. - [CDK Constructs: Abstraction with Liability](https://www.mikebild.dev/en/blog/cdk-constructs-abstraction-with-liability/): If you publish a CDK construct, you’re not shipping a helper function but operational decisions – about defaults, upgrade paths and what ends up in the consumer’s CloudFormation template. - [Bounded Contexts Before the Service Split](https://www.mikebild.dev/en/blog/bounded-contexts-before-the-service-split/): Before I split services, I clarify domain boundaries. A bounded context is a language boundary and a possible, but not mandatory, service split. - [Functional Patterns in Python: Comprehensions, itertools and functools](https://www.mikebild.dev/en/blog/functional-patterns-in-python/): Comprehensions, functools and itertools working together: how I show in projects when a comprehension is a better choice than map/filter, where lru_cache and groupby shine, and which pitfalls are waiting. - [JSX Precisely: The Rules Behind the Markup](https://www.mikebild.dev/en/blog/jsx-precisely-the-rules-behind-the-markup/): A precise look at JSX – what the compiler turns it into, why curly braces hold expressions rather than statements, how attributes, children, conditions and lists work, and where beginners stumble. - [AWS Deployment Pipelines Are Architecture](https://www.mikebild.dev/en/blog/aws-deployment-pipelines-are-architecture/): Deployment pipelines are architecture because they determine how often, how safely and how reversibly a system is changed. - [Advanced Python: Decorators, Magic Methods and Generators](https://www.mikebild.dev/en/blog/advanced-python-decorators-magic-methods-generators/): Three building blocks that make code Pythonic: decorators wrap functions, magic methods bind your own objects to Python’s protocols, generators produce lazy sequences. - [Policy as Code for CDK](https://www.mikebild.dev/en/blog/policy-as-code-for-cdk/): Policy as code makes a checkable part of your architecture rules executable and versionable. - [The Aggregate as a Consistency Boundary](https://www.mikebild.dev/en/blog/the-aggregate-as-a-consistency-boundary/): An aggregate is neither an ORM entity nor a table but a consistency and transaction boundary: a cluster of objects that an Aggregate Root protects as a unit. Why a transaction changes exactly one aggregate and other aggregates are referenced only by ID. - [`ssmenv-cli`: Small CLIs for Big Order](https://www.mikebild.dev/en/blog/ssmenv-cli-small-clis/): A small CLI on top of AWS SSM shows how configuration gets from a named, access-controlled source into local processes and CI – including questions of versions and failures. - [GitHub Actions with AWS CDK](https://www.mikebild.dev/en/blog/github-actions-with-aws-cdk/): GitHub Actions and AWS CDK connect code changes, infrastructure and deployment into a reviewable pipeline – and make the architecture decision visible in the pull request. - [PouchDB and Offline-First](https://www.mikebild.dev/en/blog/pouchdb-and-offline-first/): If you allow writes while offline, you move from request/response to replication – and the revision tree of PouchDB and CouchDB turns conflicts into a job for the domain model. - [Cleanly Separating Commands, Events and Queries](https://www.mikebild.dev/en/blog/separating-commands-events-and-queries/): Command, event and query are three kinds of messages with clear semantics: a request that can be rejected, a fact that has happened and a query without side effects. If you name and separate them cleanly, you gain clarity in the model – without a big CQRS setup. - [Infrastructure as Code Needs Code Reviews](https://www.mikebild.dev/en/blog/infrastructure-as-code-needs-code-reviews/): Once infrastructure is code, a small diff decides about security, cost and the risk of outages – that is why it belongs in the same review process as application code. - [Secrets in the Build Are Product Decisions](https://www.mikebild.dev/en/blog/secrets-in-the-build-are-product-decisions/): Secrets in the build are a trust problem: who may see, store and deploy what, and when? - [Product Discovery Before the First Line of Code](https://www.mikebild.dev/en/blog/product-discovery-before-the-first-line-of-code/): Discovery lowers the risk of efficiently building the wrong thing. I show a continuous track that tests assumptions before they tie up expensive delivery – not a phase before development. - [CQRS Is a Domain Boundary, Not a Framework](https://www.mikebild.dev/en/blog/cqrs-is-a-domain-boundary-not-a-framework/): CQRS separates the model for writing from the model for reading – a domain decision, not an installable framework. When the boundary pays off, how to start small and which mix-ups get expensive. - [Node.js Training: From the Event Loop to Architecture Decisions](https://www.mikebild.dev/en/blog/nodejs-training-from-event-loop-to-architecture/): You can’t explain Node.js through a framework. You explain it through the event loop, through streams and through the question of which architecture decision a team will still understand tomorrow – and that is exactly what I practice with participants in the introduction-nodejs repo. - [CDK Early Days: Infrastructure in a Programming Language](https://www.mikebild.dev/en/blog/cdk-early-days-infrastructure-in-a-programming-language/): With the CDK, infrastructure moves into the same toolchain as application code, which means tests, reviews, and logical identities suddenly decide whether production data survives. - [AWS Parameter Store in the Build](https://www.mikebild.dev/en/blog/aws-parameter-store-in-the-build/): Parameter Store in the build makes configuration explicit, but it raises hard questions about secrets and reproducibility. - [Running Your Own Docker Registry](https://www.mikebild.dev/en/blog/running-your-own-docker-registry/): How I set up a private Docker registry with registry:2 in projects: tagging, pushing and pulling images, then securing it with htpasswd and TLS. - [Kubernetes Basics Under Deployment Pressure](https://www.mikebild.dev/en/blog/kubernetes-basics-under-deployment-pressure/): Under the pressure of a real deployment, the Kubernetes concepts sort themselves by importance – from the pod through deployment and service to the ingress. - [Central Logging with the ELK Stack in Docker](https://www.mikebild.dev/en/blog/central-logging-with-the-elk-stack-in-docker/): Container logs are scattered across many containers and they are ephemeral. This article shows how an ELK stack of Elasticsearch, Logstash and Kibana in a Compose setup centralizes logs, indexes them and makes them searchable. - [Micro-Frontends: Team Boundaries in the Browser](https://www.mikebild.dev/en/blog/micro-frontends-team-boundaries-in-the-browser/): Why the real work in micro-frontends is not the integration technique but the team split – shown with a runnable example landscape of a gateway, four applications and a component library. - [Frontend Interfaces Are APIs](https://www.mikebild.dev/en/blog/frontend-interfaces-are-apis/): Why props, URLs, events, CSS classes and localStorage deserve the same versioning discipline as a REST endpoint – at the latest when several teams work in the same browser. - [Node.js and Redis with Docker Compose](https://www.mikebild.dev/en/blog/nodejs-and-redis-with-docker-compose/): How I describe a two-container app of Node.js and Redis with Docker Compose in projects: one YAML file for the whole stack, service discovery via the service name, persistence through a volume – and why depends_on doesn’t wait for readiness. - [Containerization and False Security](https://www.mikebild.dev/en/blog/containerization-and-false-security/): Why “runs in a container” means neither isolation nor reproducibility nor well-run operations – and which steps actually close the three gaps. - [My Working Definition of an MVP: Learning Instead of Shipping Half-Finished](https://www.mikebild.dev/en/blog/my-working-definition-of-an-mvp/): I use MVP for an experiment that honestly tests a risky assumption. This working definition keeps a merely reduced feature set from counting as learning. - [A GraphQL Schema in the Domain Language](https://www.mikebild.dev/en/blog/a-graphql-schema-in-the-domain-language/): A GraphQL schema is the best place there has ever been for the ubiquitous language of a domain – and if the domain is German, it may stay German there, too. - [Angular, React and the Value of Transitions](https://www.mikebild.dev/en/blog/angular-react-and-the-value-of-transitions/): Whether a framework switch becomes a move or a rebuild depends on how cheaply two worlds can run side by side for months. - [Prototypes: The Object Model Behind JavaScript Classes](https://www.mikebild.dev/en/blog/prototypes-the-object-model-behind-javascript-classes/): class in ES2015 is essentially syntactic sugar over prototypes: if you understand the [[Prototype]] chain, Object.create, and the new sequence, you debug this errors and shared methods with more confidence. - [Redux as a Protocol for UI Changes](https://www.mikebild.dev/en/blog/redux-as-a-protocol-for-ui-changes/): The store is the most boring part of Redux – the value lies in the message protocol of named, serializable actions that makes UI changes traceable, testable and open to discussion. - [JavaScript Patterns That Stayed: Modules, Higher-Order Functions, Currying](https://www.mikebild.dev/en/blog/javascript-patterns-that-stayed/): Three JavaScript patterns have survived every framework change: the module pattern for clean encapsulation, higher-order functions for functions as values and currying for specialized variants. Why they form the foundation of modern utility libraries. - [WebSockets Are Not Always the Answer](https://www.mikebild.dev/en/blog/websockets-are-not-always-the-answer/): Why Server-Sent Events are the simpler choice for most real-time requirements and when the price of a real WebSocket connection actually pays off. - [KnockoutJS: Fine-Grained Reactivity with Observables and Computed](https://www.mikebild.dev/en/blog/knockoutjs-fine-grained-reactivity-with-observables/): How KnockoutJS solves reactivity: observables as get/set functions, computed with automatic dependency tracking and targeted DOM updates instead of a global tree comparison. - [PWA Weather: Offline Is a Feature](https://www.mikebild.dev/en/blog/pwa-weather-offline-is-a-feature/): A small weather app built as a Progressive Web App shows why offline behavior is a product decision and how honestly a UI should deal with outdated data. - [Tic-Tac-Toe with Minimax in React](https://www.mikebild.dev/en/blog/tic-tac-toe-with-minimax-in-react/): An unbeatable tic-tac-toe opponent in React shows why game logic as a pure function must know nothing about rendering – and why immutable moves fit React’s model. - [Simple Design Can Save Process](https://www.mikebild.dev/en/blog/simple-design-can-save-process/): In many projects, process overhead compensates for a design that is too large or too speculative. Cutting smaller can save coordination; external requirements and real dependencies remain. - [HTML5, CSS3 and ECMAScript as a Baseline](https://www.mikebild.dev/en/blog/html5-css3-and-ecmascript-as-a-baseline/): In the spring of 2017, CSS Grid, Flexbox, fetch and native ES2015 carry so far that the first architecture question in the frontend deserves to be asked again: How far do I get without a framework? - [RxJS: Finally Telling Push and Pull Apart](https://www.mikebild.dev/en/blog/rxjs-telling-push-and-pull-apart/): Once you name the producer and the consumer, you see right away whether data is pulled or pushed, and you choose between function, iterator, Promise and Observable without guessing. - [Node.js: Async I/O Explains Architecture](https://www.mikebild.dev/en/blog/nodejs-async-io-explains-architecture/): The calculation “one thread times 200 connections” shows which systems fit Node.js and which work belongs in separate processes. - [Babel Node Express: Modern Syntax, Old HTTP](https://www.mikebild.dev/en/blog/babel-node-express-modern-syntax-old-http/): Babel translates syntax, not an execution model – once you keep the two apart, you know why babel-node belongs in the development loop and not in production. - [API Thinking Before Framework Thinking](https://www.mikebild.dev/en/blog/api-thinking-before-framework-thinking/): If you define operations, data and failure cases before choosing a framework, you can swap the frontend almost at will later – the other way around, you get an API that mimics a framework. - [Tyrian Rx React: UI as Data Flow](https://www.mikebild.dev/en/blog/tyrian-rx-react-ui-as-data-flow/): A rebuild of the Elm Architecture with RxJS and React – actions as a stream, scan() folds the model, side effects stay at the edge – and what this proof of concept reveals about UI architecture that ages well. - [GraphQL-Pouch: Local Data with a Schema](https://www.mikebild.dev/en/blog/graphql-pouch-local-data-with-a-schema/): An open-source experiment from the summer of 2016: a GraphQL runtime that generates a complete CRUD API on top of PouchDB from a schema shorthand – including synchronization via the CouchDB replication protocol. - [Definition of Done as a Quality Gate, Not Bureaucracy](https://www.mikebild.dev/en/blog/definition-of-done-as-a-quality-gate/): The automatable core of a Definition of Done belongs in a green gate of lint, build and test. Business acceptance and other judgments remain shared quality work. - [React: Components as Interfaces](https://www.mikebild.dev/en/blog/react-components-as-interfaces/): Why props are the public contract of a React component – and what changes when you design them like an API instead of a parameter list. - [GraphQL as a Question to the System](https://www.mikebild.dev/en/blog/graphql-as-a-question-to-the-system/): Half a year after the specification, this post sorts out what is really new about GraphQL – and which questions nobody had answered yet in early 2016. - [Build Scripts as Product Code](https://www.mikebild.dev/en/blog/build-scripts-as-product-code/): Build scripts deserve the care of product code, because they determine how reproducible a system actually is. - [ES6 Memory: Understanding UI State](https://www.mikebild.dev/en/blog/es6-memory-understanding-ui-state/): A memory game in fresh ES2015, built without a framework, makes visible which states a UI really has, where they should live and who may change them. - [Web Messaging with RxJS](https://www.mikebild.dev/en/blog/web-messaging-with-rxjs/): If you hide incoming messages behind an observable, the transport between browser and server becomes interchangeable – and you notice along the way how far plain HTTP gets you. - [Functional Styles in Everyday Code](https://www.mikebild.dev/en/blog/functional-styles-in-everyday-code/): Why functional style in everyday team work in 2015 does not mean Haskell, but the discipline of separating pure functions from I/O – and how ES2015 finally makes that convenient. - [Containers Are Not Architecture](https://www.mikebild.dev/en/blog/containers-are-not-architecture/): Docker makes system boundaries visible and portable – you still have to draw them by hand, and a monolith remains a monolith inside a container. - [Programming Styles as an Architecture Comparison](https://www.mikebild.dev/en/blog/programming-styles-as-an-architecture-comparison/): The same small task solved in dozens of programming styles is the most compact architecture comparison I know – because every style is a deliberately chosen set of constraints. - [Docker for .NET, Before It Was Normal](https://www.mikebild.dev/en/blog/docker-for-dotnet-before-it-was-normal/): Packing a small Nancy API under Mono into a Docker container was a detour via Linux in the spring of 2015 – and it taught me more about .NET deployment than any IIS manual. - [Tests Before There Is a Product](https://www.mikebild.dev/en/blog/tests-before-there-is-a-product/): Early tests help you grasp a problem, even if the code is later replaced entirely. - [Flood-It: A Game as an Architecture Lens](https://www.mikebild.dev/en/blog/flood-it-a-game-as-an-architecture-lens/): A board of numbers, a move as a pure function and a greedy solver show on a small scale what gets blurry in large systems: the separation of core logic, strategy and presentation. - [MathParser: Parsers as a Thinking Tool](https://www.mikebild.dev/en/blog/mathparser-parsers-as-a-thinking-tool/): A look back at a parser demo of my own from 2010 shows why a handwritten expression parser teaches more about layers, structure and the boundary between syntax and semantics in a few lines than many a large project. - [State Mutation on Streams](https://www.mikebild.dev/en/blog/state-mutation-on-streams/): If you compute state as a fold over a stream of events instead of changing it directly, you get undo, replay and traceability almost for free. - [HTTP APIs: Small, Stable, Readable](https://www.mikebild.dev/en/blog/http-apis-small-stable-readable/): What the Heroku HTTP API Design Guide is worth when you hold it up against your own APIs – and why a few resources, a versioning promise and self-explanatory errors achieve more than any framework. - [What I Was Looking for in Elixir](https://www.mikebild.dev/en/blog/what-i-was-looking-for-in-elixir/): It wasn’t the syntax that brought me to Elixir but the execution model of the Erlang VM – processes, messages and supervisors, seen through JavaScript and C# eyes. - [Control Flow Before `async/await`](https://www.mikebild.dev/en/blog/control-flow-before-async-await/): A look at the tiny library cflow shows how Node developers wired asynchronous steps into a chain by hand, and why the missing error channel is the real lesson. - [Why Katas Are More Than Finger Exercises](https://www.mikebild.dev/en/blog/why-katas-are-more-than-finger-exercises/): A kata is an architecture lab in miniature – because the task stays constant, it reveals what otherwise only the design knows.