Blog

A practical look at reducing blast radius in npm publishing workflows — environment-gated OIDC publishing, limiting manual access, and what consumers can do on their end.

How mixed-signals turns server-side Preact Signals into real-time shared state across clients, and what that can look like in tech like Cloudflare Durable Objects

Boilerplate became cheap, but GraphQL still wins when a durable schema contract matters across teams and clients.

How we turned Vite into a local debugging API so an LLM can inspect signal updates, page events, and network context while driving the browser.

Understanding how effect automatically tracks signal dependencies and the edge cases where you need to be intentional about subscriptions.

Understanding the critical difference between using signal values directly and wrapping them in computeds for optimal performance.

Understanding how to debug signals-based state changes and visualize the dependency graph.

Stop treating SPAs and SSR as opposing paradigms. The browser already loads resources in parallel but you have to use it.

Exploring the paradigm shift from 'render where you create state' to 'render where you use state'.

Common misconceptions about GraphQL and how persisted operations address them.

A deep dive into how signals can optimize rendering performance across various API types.

Exploring how Preact Signals promote better separation of concerns through dedicated state models.

An exploration of the trade-offs and considerations when using GraphQL and its alternatives.

Signals and the way they register on tracking contexts within your application.

In Preact 10.16 we drastically changed how we diff children in Preact, let's take a look at how it works.

Let's look at how signals can offer wins over hooks.

Fragments, a seemingly convenient subject isn't all that straight-forward.

The concept of fragment composition is great but there's a fundamentally missing feature to make it feel great

Preact X has been released for five years, let's go over all the exciting things that have happened.

What can we do to prevent our applications getting taken down by third parties, and if we do go down, how can we optimise for recovery.

A quick exploration of how a client-side cache looks at abstract and concrete types in GraphQL.

An opinionated development workflow I have enjoyed using when it comes to GraphQL.

Persisted operations are a way to introduce caching and additional security to your GraphQL Endpoint.

Getting unique tree-identifiers consistent across server and client.

When exploring a bug in Preact we came across a few quirks with regards to (micro)ticks and events.

We see a lot of talk about hydration, what is it and where is it applied?

We often talk about state in context, ... but this can be a footgun, let's take a closer look at how library authors bypass this.

How do we handle Asynchronous data in a situation where it feels the runtime is idle, how does Suspense tie into this and extending into ssr.

Controlled and uncontrolled inputs have always been a big subject, what does it actually mean, to be (un)controlled?

As one of the core maintainers of Preact I think a lot about VDOM and how to optimize the common actions of library-consumers.