Skills, A to Z

Structured editing interfaces so content teams are not fighting a page builder.

Working in iterations with visible progress, sized to the team rather than the ceremony.

Tool-using agents with iteration caps, scoped permissions, full tracing and an approval gate.

The RHEL side, which is what most cPanel hosting actually runs on.

Small amounts of interactivity in server-rendered pages without shipping a framework.

Idempotent server provisioning so a box can be rebuilt rather than resurrected.

Virtual hosts, .htaccess, mod_rewrite and the module set that shows up on shared hosting.

EC2, S3, RDS, Route 53 and CloudFront, used where its managed services genuinely earn the cost.

The glue of server work: log parsing, backups, cron jobs and one-off migrations.

Redis-backed job queues in Node, retries, backoff and dead-letter handling.

Browser, CDN, page and object caching layered so they do not fight each other.

Generative backgrounds and particle systems, with a static fallback for reduced-motion users.

Background and periodic tasks in Python, with retry policies and visible failures.

Tool use, streaming, prompt caching and structured output against a defined schema.

Saying what something will cost, what it will not fix, and when a cheaper option exists.

DNS, CDN, WAF, page rules and Workers, plus knowing which of its features cause more problems than they solve.

LVE resource limits so one busy account cannot take down every other site on the box.

Reviewing for correctness and clarity, and writing changes that are reviewable in the first place.

Encountered mostly in maintenance work on older PHP applications.

PHP dependency management, including retrofitting it onto codebases built on require_once.

LCP, CLS and INP treated as build constraints rather than a post-launch clean-up job.

Account-level administration, file and database management, and the settings that trip people up.

Scheduled jobs that report their failures instead of dying silently at 3am.

Firewall and login-failure daemon configuration on cPanel servers.

Grid, container queries, custom properties, :has(), and fluid type with clamp().

OpenLiteSpeed-based panel, useful where licence cost is the deciding factor.

Reading logs and reproducing reliably before changing anything. Guessing is slower.

Header analysis, blocklist checks, delisting requests and reputation recovery.

Droplets, volumes, Spaces and managed databases. Often the sensible default for a single application.

Lightweight alternative encountered on some hosting stacks.

Chosen when the admin, ORM and auth being there on day one is worth more than flexibility.

Record types, TTL strategy, propagation reality, and audits before a migration.

Multi-stage builds, non-root users, and Compose for development environments that match production.

Building the web stack profile and enabling the right PHP extensions per site.

Relationships and query scopes, with an eye on the N+1 problems ORMs make easy to create.

Hybrid keyword-plus-vector search, because pure vector search is weak on exact terms.

The cPanel mail transfer agent, configuration, queue inspection and log reading.

Small, unopinionated HTTP services where a full framework would be overhead.

Brute-force protection on SSH, mail and application login endpoints.

Typed Python APIs with Pydantic models and OpenAPI docs generated from the code.

When throughput and schema-validated routes matter more than the size of the plugin ecosystem.

Component transitions, gestures and layout animation in React.

Branching that suits the team size, readable history, and bisect when something needs finding.

Test, build and deploy pipelines with secrets handled properly and branch protection enforced.

The same pipeline patterns where the repository already lives on GitLab.

Read it comfortably and have written small CLI tools; would ramp up before owning a Go service.

Coverage reports, index diagnostics and monitoring after a migration.

Setup, migration and DNS configuration for business mail.

Timelines and choreography. The most reliable option when animation gets past a couple of keyframes.

Strapi and similar, where the editing experience and the frontend genuinely benefit from separation.

Hard to beat on price per unit of compute when the region suits your audience.

Semantic markup as the foundation. It is what accessibility and SEO both actually rest on.

AVIF and WebP with fallbacks, responsive srcsets and correct lazy-loading boundaries.

Containment, evidence preservation, clean-up and a written account of what happened.

React components with Laravel routing and controllers, no separate API to maintain.

Modern ES2023+ on both sides of the wire: modules, async iteration, and the browser APIs that replaced half of what jQuery did.

Used selectively; for most pipelines the direct SDK is less abstraction to debug.

Eloquent, queues, Horizon, policies, API resources and Pest, the framework I reach for most in PHP.

Smooth scrolling that keeps native behaviour, keyboard support and anchor links intact.

Automated issuance and renewal, with the renewal actually tested rather than assumed.

Lab profiling, alongside field data, because they answer different questions.

Straightforward VPS providers with predictable pricing.

Ubuntu, Debian, AlmaLinux and CentOS, provisioning, tuning and diagnosing them under load.

Server-driven interactive UI in Laravel, which keeps small teams in one language.

Test sets with expected outputs and automatic scoring, so prompt changes are measured.

Rendering designer-produced After Effects animations for icons and micro-interactions.

Backdoor hunting, root cause analysis and blocklist removal, in that order.

The default on most cPanel servers, configured and tuned to the memory actually available.

Exchange Online records, mailbox migration and client configuration.

MCP servers exposing internal systems to AI assistants in a controlled, auditable way.

Web application firewall rules, tuned so they block attacks rather than customers.

Used where it was already in place; I would ask hard questions before choosing it fresh.

Running different PHP versions per account, which is what makes staged upgrades possible.

Schema design, indexing, slow query analysis and replication for migrations.

Structure and dependency injection for Node projects large enough to need them.

When a React project needs server rendering or static generation for search visibility.

Reverse proxying, caching, rate limiting, TLS termination and rewrite rules that do what they read like.

Runtime plus the production side: graceful shutdown, supervision, structured logs and memory limits.

Lockfile discipline and audit reports that get read rather than ignored.

Media offloading, backup destinations, lifecycle policies and signed URLs.

The alternative provider, kept behind the same internal interface so switching stays cheap.

Injection, broken access control, XSS and the rest, as review criteria, not a certificate.

PHP 8 with modern syntax, enums, readonly properties, named arguments, and the discipline to work in older codebases too.

Pool sizing matched to real memory, the single most common cause of a server that swaps under load.

The other major panel, same concepts, different interface.

Node process supervision, clustering, log rotation and zero-downtime reloads.

The MTA on most non-cPanel Linux servers.

JSONB, full-text search and pgvector for embeddings when a separate vector store is overkill.

Typed database access in TypeScript with migrations kept in version control.

Service workers, offline fallbacks and installability where they solve an actual user problem.

Prompts in version control, evaluated against real examples rather than tuned by vibe.

Services, data work and server automation. Type hints on public interfaces, checked in CI.

Reading EXPLAIN output and adding the index that was never created, rather than adding another cache layer.

Chunking, embeddings, hybrid retrieval and re-ranking, with citations so answers can be checked.

Component architecture a second developer can read, with state kept as local as it can be.

Route-level code splitting, data loading and nested layouts.

Declarative Three.js in React, with drei for the parts nobody should write twice.

Caching, sessions, queues and rate limiting, with eviction policy chosen deliberately.

For log analysis, redirect maps and validation, used sparingly, because it is rarely the right parser.

Fluid type and spacing, container queries, and real testing on mid-range devices.

Structured data that matches visible content, which is what the guidelines require.

Scroll-linked sequences, pinning and scrubbing, without hijacking the browser's native scroll.

Reducing attack surface first, fewer ports, fewer services, fewer permanent credentials.

Liquid theme edits and app integration; not a platform I position myself as a specialist in.

Authentication set up in the right order, with DMARC reports read before enforcement.

Joins, window functions, and reading an EXPLAIN plan to find out why a query got slow.

Genuinely underrated for small applications, local tooling and test suites.

Key management, config files, tunnelling and jump hosts. Password login disabled everywhere.

Certificate lifecycle, modern cipher configuration, HSTS and mixed-content clean-up.

Path drawing and morphing, often the cheapest way to add motion that stays crisp at any size.

Used standalone to modernise legacy PHP without committing to a full framework rewrite.

Unit files, timers, journal analysis and resource limits per service.

Used where a team already prefers it; design tokens still live in one place either way.

READMEs that work from a clean checkout, and runbooks written before they are needed.

Crawlability, canonicals, redirects, sitemaps and index management.

Diagnosing a problem from a vague report, and explaining the fix without condescension.

Infrastructure as code where the environment is complex enough to warrant it.

Pest, PHPUnit, pytest, Vitest and Playwright, weighted toward the paths that carry money.

WebGL scenes, custom shader material and instanced geometry, budgeted against the performance cost.

Postmark, SES and Mailgun on an authenticated subdomain, separate from marketing sends.

Types where they catch real mistakes. API contracts, data models, shared code between frontend and backend.

My default for application servers, with unattended security upgrades configured from day one.

pgvector and Qdrant, chosen on whether a separate store is justified at all.

Static and edge-rendered frontends where a full server is unnecessary overhead.

The build tool I default to, fast dev server, sensible production output, easy to reason about.

Keyboard paths, focus management, contrast, heading order and reduced-motion support, tested, not assumed.

Mostly maintenance on existing configurations; new projects go to Vite.

Server-level configuration, packages, transfers, resource limits and Tweak Settings.

Billing and provisioning automation for hosting operations.

Checkout customisation, shipping and tax rules, and query tuning for large catalogues.

Custom themes and plugins, plus the recovery work on sites buried in plugin conflicts.

Bulk operations, search-replace across serialised data, and scripted migrations.