Jovi De Croock's Blog

What happens when we stop treating referential stability as a linting heuristic and start carrying it through React and Preact as a type-level proof.

How Preact resumes hydration across Suspense boundaries, why useId made that hard, and how streaming changes the tradeoffs.

A country drowning in debt decides the problem is the people still willing to build in it.

How Drydock uses npm staged publishing and GitHub release gates to review the package artifact before it can ship.

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.

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.

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.

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

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

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.

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

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.

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