Blog
Articles since 2014 on architecture, APIs, frontend, backend, delivery and method. Since late 2025 also on agentic engineering: how AI results stay verifiable.
Transparency: I have revised all articles afterwards with the help of AI and translated them from German with its help. The ideas, experience and positions are my own. The audio versions of the German originals are read by a synthetic voice.
Interim Review and System View: Taking Stock of the Series
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
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
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.
2026 15
2026 15
- Hourly Is Not Real TimeA 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.SoftwareArchitectureObservabilityDelivery
- Claims: Small, Sourced, VerifiableClaims 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.SoftwareAIMethodology
- Products Report Through Their APIProduct statistics stay understandable when every system aggregates its own data and offers it through a small HTTP contract with uniform time semantics.SoftwareArchitectureAPIDelivery
- From Org Chart to Product OwnershipAI makes the path from customer problem to impact more continuous.SoftwareAIMethodology
- llms.txt: Docs for MachinesContext for models, not for ranking: why llms.txt and llms-full.txt help coding agents – and what an MCP server makes of them.SoftwareAIMethodology
- Tools That Hold Up: Concepts, Methods, ProcessesYou 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.SoftwareAIMethodologyDelivery
- AI Agents per Domain: Rules, Approvals and EvidenceHow an AI agent enforces domain rules across several tool calls: with case state, checked plans, approvals and traceable execution.SoftwareAIMethodologyDelivery
- MCP Security: Tools, Permissions and Approvals for AI AgentsHow to integrate MCP tools into applications safely: server-side permission checks, human approvals, protection against prompt injection and traceable calls.SoftwareAIArchitecture
- Agent, Model, DomainThe 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.SoftwareAIMethodologyDelivery
- Knowledge That Survives the SessionSession 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.SoftwareAIMethodologyDelivery
- Clean Grounding II: Grounding AnswersMy 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.SoftwareAIMethodologyDelivery
- AI in the Enterprise: Faster Development Needs Different ProcessesAI 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.SoftwareAIArchitectureDelivery
- Clean Grounding I: Why AI Guesses So ConvincinglyWhy language models invent plausible things, why more training doesn’t reliably eliminate the problem and what grounding has to do with it.SoftwareAIMethodologyDelivery
- My Success Cannot Be CopiedA 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.SoftwareAIMethodologyDelivery
- What I Am Critical OfFour 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.SoftwareAIMethodology
2025 2
2025 2
- Good Enough: The Model Is Rarely the BottleneckFor 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.SoftwareAIMethodology
- From Tool to Way of WorkingHow 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.SoftwareAIMethodology
2024 29
2024 29
- React Overview: From JSX to Component ArchitectureA 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.SoftwareFrontendReact
- Forms in React 19: Actions, useActionState and useOptimisticReact 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.SoftwareFrontendReact
- React Server Components and Server Actions: The New BoundaryServer 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.SoftwareFrontendReact
- React Router Data Router: The URL as the Place for StateThe 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.SoftwareFrontendReact
- React Transitions: Non-Urgent Updates with useTransitionuseTransition marks updates as non-urgent and keeps React responsive during expensive or suspending renders. Plus useDeferredValue as the tool for downstream renders.SoftwareFrontendReact
- React Testing Without TheaterTests 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.SoftwareTesting
- Suspense and the use Hook: Rendering as If the Data Were Already ThereInstead 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.SoftwareFrontendReact
- Client State vs. Server Cache: The Most Consequential Boundary in the FrontendServer 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.SoftwareFrontendReact
- Testing Schedulers and Virtual TimeInjectable time makes time-dependent rules testable quickly and deterministically. Data, isolation and external systems remain unaffected by it.SoftwareReactive
- GraphQL Overview: From Schema to Federated APIA walk through GraphQL – from the typed schema through queries and resolvers to real time, operations and federated architecture, assessed as of October 2024.SoftwareAPIGraphQL
- HTTP/2 and Server-Sent Events in Node.jsHow 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.SoftwareNode.jsBackend
- Markdown Reports Instead of Dashboard MandatesWhy a diffable Markdown report often does more for traceability, review and operations than a dashboard – and how I set that up architecturally.SoftwareContentPublishing
- GraphQL Federation: One Schema from Many SubgraphsWhen 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.SoftwareGraphQLAPI
- Fuzzy Matching with Explicit LimitsA 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.SoftwareDataTools
- Event Sourcing on AWS: DynamoDB Streams and LambdaEvent 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.SoftwareAWSCloud
- Testing RxJS with Marble DiagramsMarble diagrams make the timing of asynchronous streams visible. With TestScheduler.run and virtual time, you test RxJS operators deterministically: no real waiting, no flakiness.SoftwareReactive
- Invoice Data as a DomainWhy 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.SoftwareDataTools
- Testing Node.js: The Test Pyramid with MochaHow 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.SoftwareNode.jsBackend
- Deterministic CLIsDeterminism is an architecture decision: same inputs, same report, reviewable via diff. It pays off wherever an artifact is checked repeatedly.SoftwareDataTools
- Observability with OpenTelemetry: Logs, Traces and MetricsInstrument logs, traces and metrics consistently with OpenTelemetry, connect them through trace IDs and export them via OTLP to suitable backends.SoftwarePlatform
- The GraphQL Client: Apollo Link and FragmentsApollo 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.SoftwareGraphQLAPI
- OCR with a Cache and DistrustWhy 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.SoftwareDataTools
- The Four Subject Types in RxJSSubject, BehaviorSubject, ReplaySubject and AsyncSubject differ in what late subscribers see and in how completion or an error ends their stored behavior.SoftwareReactive
- Apollo Client: The Normalized Cache and Optimistic UpdatesHTTP 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.SoftwareGraphQLAPI
- Securing GraphQL: Query Depth, Complexity and Rate LimitingA 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.SoftwareGraphQLAPI
- TypeScript in Node.js: Setup, Types and TestsSetting 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.SoftwareNode.jsBackend
- TypeScript in React: Typing Props, Hooks and EventsHow 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.SoftwareFrontendReact
- Resilience Patterns: Timeout, Retry, Circuit Breaker, IdempotencyWhy 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.SoftwareArchitecture
- GraphQL Subscriptions over SSE: Real Time Without Being Forced into WebSocketSubscriptions 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.SoftwareGraphQLAPI
2023 11
2023 11
- Contract Testing Instead of an E2E MarathonConsumer-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.SoftwareDelivery
- Errors as Architecture in Node.js: Safety Nets Against the CrashError 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.SoftwareNode.jsBackend
- DORA Metrics: What Really Shortens Development CyclesLead 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.SoftwareDelivery
- child_process in Node.js: Scaling Without IllusionsNode.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.SoftwareNode.jsBackend
- Understanding Lambda Performance and Cold StartsWhat 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.SoftwareAWSCloud
- RxJS in Node.js: Processing Event Streams ReactivelyRxJS 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.SoftwareNode.jsBackend
- Evolutionary Architecture: Systems That Are Allowed to ChangeArchitecture 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.SoftwareArchitecture
- From HOCs and Render Props to Custom HooksHow 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.SoftwareFrontendReact
- Async Context in Node.js: AsyncLocalStorage, async_hooks and diagnostics_channelHow 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.SoftwareNode.jsBackend
- GraphQL Auth: Identity in the Context, Authorization in the Domain LogicThe 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.SoftwareGraphQLAPI
- Debugging and Profiling Node.js LocallyFrom the console.log reflex to the built-in inspector: node --inspect, the debug module, nodemon and first CPU and memory profiles for local diagnosis.SoftwareNode.jsBackend
2022 16
2022 16
- Developer Productivity: Shorter Cycles with High QualityShort 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.SoftwareDelivery
- Slots, Context and Web Components in SvelteThree 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.SoftwareFrontendSvelte
- Build vs. Runtime in Web ProjectsThe rendering time is decided per route. Static, dynamic and incremental models can be combined according to data shelf life, cost and failure behavior.SoftwareFrontend
- Streams in Object Mode: Data Pipelines Beyond BytesNode.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.SoftwareNode.jsBackend
- Reproducible Test Pipelines: No Flakiness, No ChanceFlakiness 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.SoftwareDelivery
- Adapter Design: Where Frameworks EndWhat 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.SoftwareAWSCloud
- RxJS in React: Observables in the UI Data FlowRxJS 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.SoftwareFrontendReact
- Motion, Transitions and Animations in SvelteHow 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.SoftwareFrontendSvelte
- Buffers in Node.js: Working with Binary DataWhy 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.SoftwareNode.jsBackend
- Svelte Stores: State Outside the ComponentSvelte 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.SoftwareFrontendSvelte
- Node.js Streams: Understanding and Using BackpressureWhy 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.SoftwareNode.jsBackend
- Fitness Functions: Checking Selected Architecture PropertiesFitness functions make selected properties such as coupling, dependencies and latency continuously checkable. They don’t replace domain quality or architectural trade-offs.SoftwareArchitecture
- Svelte Reactivity: The Compiler Instead of a Virtual DOMSvelte 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.SoftwareFrontendSvelte
- EventEmitter: The Event Model at the Core of Node.jsEventEmitter 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.SoftwareNode.jsBackend
- GraphQL Pagination: Cursors, Connections and the Relay PatternWhy 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.SoftwareGraphQLAPI
- SvelteKit Adapter AWS: Framework Meets CloudWhy 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.SoftwareAWSCloud
2021 20
2021 20
- Preview Environments per Pull RequestEphemeral environments per pull request shorten feedback and make reviews concrete: you click through the change instead of imagining it from the diff.SoftwareDelivery
- Jamstack as an Architecture Style for Web ApplicationsJamstack 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.SoftwareArchitecture
- Serverless Transactional Email: SES and LambdaHow 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.SoftwareAWSCloud
- State Management in React: Redux Toolkit, Lightweight Stores, MobXWhen 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.SoftwareFrontendReact
- DynamoDB Data Modeling: Single-Table DesignDynamoDB 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.SoftwareAWSCloud
- CDN Construct: A Small Infrastructure APIWhy a custom CDK construct for static websites is more than saved lines: an opinionated interface over S3, CloudFront, certificates and DNS.SoftwareAWSCloud
- Outcome Before Output: Why Velocity Is the Wrong NumberCompleted tickets are output, but not yet evidence of impact. Why velocity misleads in management reporting and how to align teams with outcomes instead.SoftwareProduct
- Data Analysis with NumPy, Pandas, and MatplotlibFrom raw data to insight: how NumPy, pandas, and Matplotlib work together – vectorized computation, groupby aggregation, and a quick plot in a small pipeline.SoftwarePythonData
- When CQRS and Event Sourcing Are Too MuchFor 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.SoftwareArchitecture
- GraphQL Concepts: Schema, Resolvers, ExecutionThe 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.SoftwareAPIGraphQL
- GraphQL APIs with AppSync and DynamoDBAWS 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.SoftwareAWSCloud
- Using Context Well: A Distribution Path, Not Secret Global StateContext 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.SoftwareFrontendReact
- Reading Data in Python: CSV, JSON, Excel and DatabasesA 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.SoftwarePythonData
- Architecture Decision Records: Decisions You Will Still Understand in Two YearsWhy 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.SoftwareArchitecture
- A GraphQL Schema That Grows: Evolution Without BreakageHow 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.SoftwareAPIGraphQL
- Serverless Workflows with AWS Step FunctionsStep Functions turn nested Lambda handlers into a declarative state machine: a visible flow, explicit retry and catch paths, Standard or Express.SoftwareAWSCloud
- Event Sourcing: The Event Store as a LogbookEvent 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.SoftwareArchitecture
- Testing Flask Apps: The Test Client and Reliable EndpointsHow I test Flask endpoints: with app.test_client() without a running server, pytest fixtures and verified JSON responses.SoftwarePythonBackend
- Preserving and Resetting State: React and the Position in the TreeReact 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.SoftwareFrontendReact
- Serverless Auth with Cognito User PoolsCognito 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.SoftwareAWSCloud
2020 16
2020 16
- Trunk-Based Development Instead of a Branch GraveyardShort 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.SoftwareDelivery
- How React Renders and Updates the TreeFrom 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.SoftwareFrontendReact
- Team Automation with GitHub ActionsWhy I run selected, recurring checks as workflows – and how you can tell whether the automation actually takes load off the team.SoftwareArchitecture
- Web APIs with Flask: From the App to a JSON APIFrom 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.SoftwarePythonBackend
- Read Models from Events: Projections Instead of Accidental CachesA 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.SoftwareArchitecture
- Cloud Guardrails Instead of Cloud GatekeepingWhy 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.SoftwareArchitecture
- CDK Constructs: Abstraction with LiabilityIf 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.SoftwareAWSCloud
- Bounded Contexts Before the Service SplitBefore I split services, I clarify domain boundaries. A bounded context is a language boundary and a possible, but not mandatory, service split.SoftwareArchitecture
- Functional Patterns in Python: Comprehensions, itertools and functoolsComprehensions, 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.SoftwarePythonBackend
- JSX Precisely: The Rules Behind the MarkupA 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.SoftwareFrontendReact
- AWS Deployment Pipelines Are ArchitectureDeployment pipelines are architecture because they determine how often, how safely and how reversibly a system is changed.SoftwareAWSCloud
- Advanced Python: Decorators, Magic Methods and GeneratorsThree building blocks that make code Pythonic: decorators wrap functions, magic methods bind your own objects to Python’s protocols, generators produce lazy sequences.SoftwarePythonBackend
- Policy as Code for CDKPolicy as code makes a checkable part of your architecture rules executable and versionable.SoftwareAWSCloud
- The Aggregate as a Consistency BoundaryAn 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.SoftwareArchitecture
- `ssmenv-cli`: Small CLIs for Big OrderA 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.SoftwareDataTools
- GitHub Actions with AWS CDKGitHub Actions and AWS CDK connect code changes, infrastructure and deployment into a reviewable pipeline – and make the architecture decision visible in the pull request.SoftwareAWSCloud
2019 9
2019 9
- PouchDB and Offline-FirstIf 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.SoftwareArchitecture
- Cleanly Separating Commands, Events and QueriesCommand, 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.SoftwareArchitecture
- Infrastructure as Code Needs Code ReviewsOnce 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.SoftwareAWSCloud
- Secrets in the Build Are Product DecisionsSecrets in the build are a trust problem: who may see, store and deploy what, and when?SoftwareDevOpsArchitecture
- Product Discovery Before the First Line of CodeDiscovery 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.SoftwareProduct
- CQRS Is a Domain Boundary, Not a FrameworkCQRS 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.SoftwareArchitecture
- Node.js Training: From the Event Loop to Architecture DecisionsYou 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.SoftwareNode.jsBackend
- CDK Early Days: Infrastructure in a Programming LanguageWith the CDK, infrastructure moves into the same toolchain as application code, which means tests, reviews, and logical identities suddenly decide whether production data survives.SoftwareAWSCloud
- AWS Parameter Store in the BuildParameter Store in the build makes configuration explicit, but it raises hard questions about secrets and reproducibility.SoftwareFrontendAWS
2018 10
2018 10
- Running Your Own Docker RegistryHow I set up a private Docker registry with registry:2 in projects: tagging, pushing and pulling images, then securing it with htpasswd and TLS.SoftwarePlatform
- Kubernetes Basics Under Deployment PressureUnder the pressure of a real deployment, the Kubernetes concepts sort themselves by importance – from the pod through deployment and service to the ingress.SoftwarePlatform
- Central Logging with the ELK Stack in DockerContainer 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.SoftwarePlatform
- Micro-Frontends: Team Boundaries in the BrowserWhy 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.SoftwareFrontend
- Frontend Interfaces Are APIsWhy 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.SoftwareFrontend
- Node.js and Redis with Docker ComposeHow 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.SoftwarePlatform
- Containerization and False SecurityWhy “runs in a container” means neither isolation nor reproducibility nor well-run operations – and which steps actually close the three gaps.SoftwarePlatform
- My Working Definition of an MVP: Learning Instead of Shipping Half-FinishedI use MVP for an experiment that honestly tests a risky assumption. This working definition keeps a merely reduced feature set from counting as learning.SoftwareProduct
- A GraphQL Schema in the Domain LanguageA 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.SoftwareGraphQLAPI
- Angular, React and the Value of TransitionsWhether a framework switch becomes a move or a rebuild depends on how cheaply two worlds can run side by side for months.SoftwareFrontend
2017 11
2017 11
- Prototypes: The Object Model Behind JavaScript Classesclass 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.SoftwareFrontend
- Redux as a Protocol for UI ChangesThe 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.SoftwareFrontend
- JavaScript Patterns That Stayed: Modules, Higher-Order Functions, CurryingThree 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.SoftwareFrontend
- WebSockets Are Not Always the AnswerWhy Server-Sent Events are the simpler choice for most real-time requirements and when the price of a real WebSocket connection actually pays off.SoftwareNode.jsBackend
- KnockoutJS: Fine-Grained Reactivity with Observables and ComputedHow KnockoutJS solves reactivity: observables as get/set functions, computed with automatic dependency tracking and targeted DOM updates instead of a global tree comparison.SoftwareFrontend
- PWA Weather: Offline Is a FeatureA 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.SoftwareArchitecture
- Tic-Tac-Toe with Minimax in ReactAn 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.SoftwareFrontend
- Simple Design Can Save ProcessIn 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.SoftwareProduct
- HTML5, CSS3 and ECMAScript as a BaselineIn 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?SoftwareArchitecture
- RxJS: Finally Telling Push and Pull ApartOnce 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.SoftwareReactive
- Node.js: Async I/O Explains ArchitectureThe calculation “one thread times 200 connections” shows which systems fit Node.js and which work belongs in separate processes.SoftwareNode.jsBackend
2016 7
2016 7
- Babel Node Express: Modern Syntax, Old HTTPBabel 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.SoftwareNode.jsBackend
- API Thinking Before Framework ThinkingIf 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.SoftwareGraphQLAPI
- Tyrian Rx React: UI as Data FlowA 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.SoftwareReactive
- GraphQL-Pouch: Local Data with a SchemaAn 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.SoftwareGraphQLAPI
- Definition of Done as a Quality Gate, Not BureaucracyThe 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.SoftwareDelivery
- React: Components as InterfacesWhy props are the public contract of a React component – and what changes when you design them like an API instead of a parameter list.SoftwareFrontend
- GraphQL as a Question to the SystemHalf 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.SoftwareGraphQLAPI
2015 7
2015 7
- Build Scripts as Product CodeBuild scripts deserve the care of product code, because they determine how reproducible a system actually is.SoftwareTooling
- ES6 Memory: Understanding UI StateA 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.SoftwareFrontend
- Web Messaging with RxJSIf 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.SoftwareReactive
- Functional Styles in Everyday CodeWhy 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.SoftwareArchitecture
- Containers Are Not ArchitectureDocker makes system boundaries visible and portable – you still have to draw them by hand, and a monolith remains a monolith inside a container.SoftwarePlatform
- Programming Styles as an Architecture ComparisonThe 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.SoftwareArchitecture
- Docker for .NET, Before It Was NormalPacking 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.SoftwarePlatform
2014 8
2014 8
- Tests Before There Is a ProductEarly tests help you grasp a problem, even if the code is later replaced entirely.SoftwareTesting
- Flood-It: A Game as an Architecture LensA 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.SoftwareLearning
- MathParser: Parsers as a Thinking ToolA 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.SoftwareArchitecture
- State Mutation on StreamsIf 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.SoftwareReactive
- HTTP APIs: Small, Stable, ReadableWhat 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.SoftwareArchitecture
- What I Was Looking for in ElixirIt 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.SoftwareArchitecture
- 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.SoftwareNode.jsBackend
- Why Katas Are More Than Finger ExercisesA kata is an architecture lab in miniature – because the task stays constant, it reveals what otherwise only the design knows.SoftwareTesting