Your team already knows how to code. We teach them how to keep a codebase healthy.
Testing, static analysis, refactoring, architecture. Taught on-site by someone who does this in production systems every day, not from slides written by someone who doesn't.
Most developers are self-taught when it comes to practices like testing, static analysis, and refactoring. They've picked up bits from blog posts, conference talks, and whatever the last team they worked on happened to do. Some of it is good. Some of it has gaps.
The result is a team where everyone has a slightly different idea of what "good" looks like. Tests exist but don't catch the right things. Static analysis is installed but nobody trusts the output. Refactoring happens ad hoc rather than with a clear method. Architecture conversations go in circles because there's no shared vocabulary.
This isn't a talent problem. It's a training problem. And it's fixable.
What we teach
Every workshop is built around four themes. The content is tailored to your team, your codebase, and where you are right now.
Testing
Not "how to write a test." How to build a test suite that actually protects you. We cover the properties of unit, integration, and system tests: what each level catches, how fast they run, how to architect code so it's testable, and where to make trade-offs. We also teach developers how to decouple their test code from the code under test, so your tests don't become a second maintenance burden.
Static analysis
Tools like PHPStan and Psalm can catch entire categories of bugs before they reach production. Most teams install them and stop there. We show your developers how to write code that gets the most from static analysis, how to introduce these tools to legacy projects without drowning in warnings, and how to write custom rules that enforce your team's specific standards automatically.
Refactoring
Every team has code they're afraid to touch. We teach structured approaches to refactoring, from small-scale techniques your developers can use daily to strategies for upgrading legacy codebases safely. This includes using automated refactoring tools like Rector to handle repetitive changes that would take weeks to do by hand.
Architecture
Decoupled code is easier to understand, test, and extend. We cover practical architecture patterns, dependency injection, event-driven design, and how to make decisions about system structure that your team can maintain long after the workshop ends.
How it works
1. We find out where you are
Before any workshop, we talk to your team leads and look at your codebase. We need to understand what your developers already know, what gaps exist, and what problems they're hitting day to day. This shapes everything we teach.
2. We build the workshop around your reality
The themes are consistent, but the content is bespoke. If your team is struggling with flaky tests, we focus there. If static analysis has been tried and abandoned, we work through why and fix the approach. If architecture has drifted and nobody knows how the system fits together, that's where we start.
We use your code in the workshop where possible. Exercises built around a familiar codebase land better than abstract examples.
3. We deliver on-site
Workshops happen at your office, with your team, working through real problems together. The format is flexible: it might be a focused day on testing, a two-day deep dive on architecture and refactoring, or a series of shorter sessions spread across weeks. We work out what fits.
4. Your team leaves with something usable
Every session ends with practical takeaways your developers can apply immediately. Not theory they'll forget by Friday. Techniques, tools, and approaches they can use the next time they write code.
Who teaches this
Training at Lamp is led by Dave Liddament.
Dave has been writing software commercially for over 21 years and speaks regularly at international conferences including SymfonyCon, the International PHP Conference, PHP UK Conference, phpday, and ConFoo. His talks cover the same ground as the workshops: testing strategy, static analysis, code quality, legacy upgrades, and architecture.
He's also the author of SARB (Static Analysis Results Baseliner), an open source tool used to introduce static analysis to existing projects without being overwhelmed by historical warnings. And he created the PHP Language Extensions library, which uses static analysis to enforce additional language features at development time.
Dave organises PHP-SW, Bristol's PHP meetup, and runs Bristol PHP Training, a free monthly workshop covering testing, CI, and development practices.
This matters because the person training your team isn't a professional trainer who learned the material from a manual. He's an engineer who does this work, builds tools for it, contributes to the community around it, and has been refining how to teach it through years of conference talks and hands-on workshops.
What this isn't
This isn't a generic training course pulled off a shelf. We don't have a fixed curriculum or a standard slide deck. If you want a three-day "Introduction to Unit Testing" that your team sits through and forgets, there are cheaper options.
This is for teams that want their practices to actually change. That means the content has to connect to the work they do every day, on the codebase they maintain, with the tools they already use.
What we expect from you
Good fit
- Your team has working developers who need sharper practices
- You want training grounded in production experience, not academic theory
- You're willing to set aside real time for your team to learn
- You want measurable improvement in code quality, test coverage, or release confidence
Not for you
- You need a certificate for compliance purposes
- You want training delivered to hundreds of people at once
- You're looking for introductory programming courses
- You expect a slide deck and a multiple-choice quiz
Start a conversation
Tell us what your team is working on and where the gaps are. We'll talk through whether training is the right next step and what a useful workshop would look like. No obligation, no hard sell.