Uses

What I build with, what I host on, and a set of habits that cost me something to learn. The list stays short on purpose: every dependency in a plugin is a dependency in somebody else's site.

6 categories · 33 entries

What I reach for when the thing being built is an application rather than a page.

Laravel

An API that could have a second client put in front of it, rather than a framework quietly rendering its own front end. Sanctum for authentication; the authorisation layer is written by hand.

Vue 3, Composition API

Composition over Options for anything non-trivial. Logic that belongs together lives together, and it can be pulled out into a composable the day a second screen needs it.

Pinia

One store per domain, each owning its own loading and error state. A single global store is comfortable for a week and unreadable by the third feature.

Vite

The build for everything — applications and plugin interfaces both. Fast enough that a React panel inside wp-admin stops feeling like a compromise.

Tailwind

Tokens in one file, utilities everywhere else. The token layer is the part that matters; the utilities are only how it gets applied.

Nuxt

This site. Prerendered, with a bundle budget that fails the build rather than being admired in a readme.

Two stacks, kept apart. Application work and WordPress work do not share an environment.

Laragon

Where the Laravel side lives. Apache, PHP and MySQL without an afternoon of configuration.

LocalWP

One throwaway site per plugin. A plugin has to be installed on a clean WordPress before I believe it works.

MySQL

The database under both stacks. Enough of it that a data migration can be a query rather than a plugin.

A test suite that runs locally

Just over a hundred suites on the form plugin alone. They exist because it ships to sites I will never see, and no amount of clicking replaces that.

A guarded release script

Building a release by hand is how a stray development file ends up in a zip. The script refuses rather than reminds me.

The layer underneath everything else. Unglamorous, and the part I would miss first.

Git

Every project is a repository, including the client sites that were never supposed to have one. It is also the reason I can work on a live site and still have a way back.

Git Bash on Windows Terminal

POSIX habits on a Windows machine. Most tooling assumes a Unix shell, and it is less work to bring one than to translate every command.

GitHub

Public for the plugins, private for client work. Actions for anything that has to happen on a schedule.

Composer

PHP dependencies, and increasingly the autoloader inside plugins that used to get by without one.

npm

The other half of every build. Kept boring on purpose — a dependency in a plugin is a dependency in somebody's site.

What goes into a plugin, and what goes onto a client site. Two different lists with two different standards.

React with @wordpress/components

Plugin interfaces are applications mounted inside wp-admin. Using the WordPress components is why they look like they belong there rather than like something bolted on.

dnd-kit

Dragging that works from a keyboard and announces itself to a screen reader. Retrofitting that is far more expensive than choosing it.

The WordPress REST API

The only seam between a plugin's PHP and its interface. It is what makes the PHP testable without a browser anywhere near it.

Advanced Custom Fields Pro

For client sites, where the content model lives. Fields named in the client's vocabulary, not the database's.

Elementor

Not a compromise — the right answer when an in-house team edits weekly. Locked templates, a small palette, global styles set once.

WooCommerce

With as few extension plugins as the requirement genuinely needs. Every add-on is a licence somebody has to keep paying.

Mostly other people's infrastructure. The skill is working inside constraints I did not choose.

The client's own hosting

Shared hosting, a control panel, no staging environment and no deploy pipeline. That is the honest description of most WordPress work, and pretending otherwise is how a rebuild gets quoted when a fix was needed.

FTP against production

Not a preference, a constraint of agency work. It teaches one discipline above all: change one thing, verify it, keep a way back.

Cloudflare

DNS, CDN and Pages. This site is prerendered and served from it.

A transactional email provider

Site mail leaves through a real provider, never the web host's PHP mail. This is the single most common reason a contact form fails silently.

Backups the client owns

To storage in their account, not mine. Leaving me should never mean leaving their data.

Process rather than software. Most of it was learned the expensive way.

Model the data before the interface

The fastest way to make something expensive to own is to build the screens first and discover the shape of the data afterwards. True of a Laravel schema and of an ACF field group alike.

Read the source before the documentation

Learned in two years of having nobody to ask. It is still the fastest route into an unfamiliar framework, and it is why picking up a new one is a week rather than a season.

Ask who maintains it, before choosing how to build it

The same question opens every project. It decides page builder or custom theme, and it decides how much of an application belongs in its API rather than its front end.

Deep work in the morning, calls at night

US clients, Dhaka time zone. The overlap is my evening, which leaves the mornings uninterrupted.

A repeated complaint is a specification

The same request from four unrelated clients is not an inconvenience. It is the only market research a one-person shop gets for free, and every plugin I have finished started there.

Write the handover in the maintainer's language

One of my plugins ships its maintainer notes in Bengali. Documentation somebody has to translate before using is documentation that will not be used.