Stack & tools

Main stack. Mature ecosystem, Eloquent for day-to-day work, and a community that has already solved 90% of the common problems.

Where performance matters. Keeps the application in memory between requests and removes the boot cost of the traditional PHP cycle. On heavily-hit query routes the difference is noticeable.

For services where strong typing and the enterprise ecosystem pay off. Spring covers security, persistence and configuration out of the box.

Not a choice, a reality of many production systems. Moving through a legacy codebase without breaking it is a skill in itself.

JavaScript on the backend, mostly on web projects where the rest of the stack already lives in the same language.

Frontend, scripting and tooling. TypeScript whenever the project is meant to outlive a couple of months.

Main frontend framework. The Composition API keeps logic organised as components grow.

On top of Vue, for management applications: extranets, intranets and dashboards. A consistent component catalogue that avoids rebuilding the design system per surface.

On projects where the team or client already uses it. Function components with hooks, without dragging in a heavy framework on top.

For frontends that want a stricter, typed structure out of the box — common in management applications with larger teams.

Custom development on WordPress when the client needs to manage their own content without depending on anyone.

For content sites like this one. Zero JavaScript by default and Markdown content without standing up a CMS.

Utility-first. Visual consistency without accumulating a stylesheet nobody dares to touch.

The databases I have run in production. Well modelled and indexed, they hold far more than people assume before anything exotic is needed.

Cache, sessions and frequently-accessed data. In an availability engine it is the difference between answering instantly and asking the database the same question again.

The schema is the most expensive decision to reverse in a system. It deserves more time than it usually gets.

Reading execution plans, understanding which index is being used and why. In systems under real load this is where the big wins are.

Separating reads from writes when query volume vastly exceeds write volume, which is the norm for availability engines.

The cloud provider I work with. EC2, RDS and S3 cover most of what a backend needs without adding services for fashion.

Reproducible environments. Compose for local development with reasonable parity to production.

Infrastructure declared as code. The real value is not automating provisioning, it is being able to read in a repository what exists and why.

Reverse proxy, TLS termination and security headers. The piece that almost never causes trouble, which is why it gets forgotten.

Where everything ends up running. Being able to read logs, processes and resource usage saves an enormous amount of diagnosis time.

Absorbing load peaks without oversizing infrastructure for the rest of the time.

Continuous integration and delivery. If deploying is scary you deploy rarely, and if you deploy rarely each deploy is riskier.

Designing APIs around the consumer, not around how the database happens to be organised.

One adapter per provider, one model internally. Every provider quirk contained in a single place.

Without ceremony: what matters is the boundaries and the direction of dependencies, not reproducing a diagram.

Measure before optimising, and prioritise not doing work over doing it faster.

JetBrains IDEs for PHP and Java. Automated refactoring and code navigation pay for themselves in large codebases.

For frontend, TypeScript, Terraform and Markdown.

Version control, reviewed pull requests and protection on the main branch.