Insights

Short reads from the work — process, build-or-buy, and North East operations.

Chapter check: environment and development workflow
Chapter project: environment sign-off and first simulator run
Jump vs `native:run` — when to use which
Hot reload: Vite HMR and `native:watch`
`native:jump` — network, QR code, and `--no-serve`
After install: `config/nativephp.php`, ICU, and generated files
Android Studio, SDK, and USB debugging
Xcode setup for iOS simulators and real devices
Laravel Herd, Sail, or manual PHP — pick one
PHP, Composer, and Node versions that match v3
Mac vs Windows vs Linux constraints (incl. no WSL)
Chapter check: NativePHP Mobile orientation
Chapter project: your first screen on mobile
Jump, `native:run`, and `native:watch`
Get a Laravel app running locally
EDGE: native UI in one lesson
The plugin model at a glance
PHP on the device — not on your server
Why Laravel is the foundation (not optional)
An Introduction to NativePHP
Chapter project: reusable formatter pipeline
Refactor: from long function to small units
Error-first thinking in function design
Recursion and call stack limits
Pure vs impure functions
Function composition with map, filter, and reduce
Early returns for readable functions
Guard clauses to flatten nested logic
bind, call, and apply for context control
this in normal functions: call-site rules
Arrow functions and lexical this
Callback timing: who calls your function
Closures with real-world callback examples
Block scope with let/const vs PHP habits
Returning values vs mutating outer state
Parameters, defaults, and rest arguments
Chapter project: port a PHP utility file to JS
PHP-to-JS syntax translation drills
try/catch for safer scripts
Modules 101: export and import
Function declarations vs expressions
Object basics: keys, values, and access
Array basics: create, read, update safely
Loop choices: for, while, for...of
Nullish coalescing and optional chaining
if, ternary, and switch for clear branching
Equality done right: === over ==
Truthy/falsy values that surprise PHP devs
Numbers, parsing, and NaN handling
Strings and template literals
Primitive types and typeof in practice
let, const, and why var causes bugs
Exercise: Build CRUD Routes
Error Handling & Exceptions
API Routing Basics
Handling Redirects
Middleware Introduction
Custom Route Binding
Route Model Binding
Form Data & Validation Basics
Request Object & Input Handling
Dependency Injection in Controllers
Single Action Controllers
Controllers Deep Dive
Route Groups & Prefixes
Named Routes & URL Generation
Galactic Strike: a space shooter we built just for fun
Route Parameters & Constraints
Basic Routing (GET, POST, etc.)
The meeting that replaced the system
Hiring will not fix a broken handoff
Mini Project: Hello Laravel App
Founder bottleneck: decisions that should not need you
Laravel Philosophy
When growth outpaced the spreadsheet: warning signs before the snap
Debugging Basics
Everyone busy, nothing moving: the coordination tax
Migrations Intro
Database Intro
Night shift handoffs: continuity without another WhatsApp group
Blade Basics
Supplier chasing: when the PO lives in three places
Controllers Introduction
Seasonal ramp without breaking the system
Factory floor to finance: when ops and accounts speak different languages
Returning Responses
Routing Basics
Teesside Tuesday: when local context beats another remote ticket
Dashboards nobody opens: fix the metric that matters
Artisan CLI Basics
Environment Configuration
Training that survives go-live: change management beyond the slide
Understanding the Request Lifecycle
Naming owners for every alert: on-call without heroics
Running Your First App
When CRM and finance disagree: reconciliation as a product
Project Structure Overview
One report the room trusts: building a single source of truth
Data migration: what you can actually move on go-live day
Installing Laravel
What is Laravel?
Phase one scope: cap the first build without killing the vision
Solution: pull and smoke-test an image
The RFP trap: buying software for a process you never mapped
Exercise: pull and smoke-test an image
Integrate before you replace: when connecting beats ripping out
When build, pull, or cache goes wrong
Make vendor demos prove your workflow, not theirs
API Best Practices
Build context and .dockerignore
Fat bases, slim bases, and distroless choices
Tags vs digests (sticky note vs serial number)
docker history, image size, and layer dedup
Build, tag, and inspect an image locally
Pull, run, and smoke-test an image
Image vs container and the layer stack
Solution: add a healthcheck to nginx
Exercise: add a healthcheck to nginx
Verify with curl, logs, and healthchecks
One job per container and when to reach for Compose
App code in the image, data in a volume
Rebuild instead of patching by hand
Why teams use Docker
The words you need first
Run your first container and learn the core commands
Is custom software worth it? How to run the numbers
Check that Docker actually works
Local systems help still matters (even with the cloud)
Install Docker on your machine
Draw the process before you buy the app: five non-negotiables
Whose job is the system? Ownership that actually ships
Chapter 2 guided practice
CRM without chaos: the smallest setup that still sells
A small naming cleanup walkthrough
Email is not a workflow: the real cost of constant CC and reply-all
Reviewing names in context
When to automate, when to keep the manual step
Renaming code safely
The hidden cost of 'we will sort it in the next tool'
When old names hide new behaviour
Bespoke build or off the shelf: twelve questions in one hour
Abbreviations, acronyms, and team context
When one person holds the truth: a handover plan that survives leave
Avoiding vague utility language
Quotes, jobs, and invoices: closing the gap (UK trades and field teams)
Using domain language consistently
A simple ROI model for changing how you work (not just for the accountant)
File and folder naming
Security basics that fit an SME: boring and worth doing
Better class names
Your new website is not a CRM: what to fix in operations first
Naming collections and groups
Quarterly systems check-in: what to review without buying more tools
Better function names
Better boolean names
Better variable names
Naming by intent, not by type
Chapter 1 guided practice
Build your Chapter 1 action plan
What each chapter is trying to achieve
It depends: performance, cost, and context
Verification checks before you apply this in the wild
Preventing code rot with practical team habits
Code rot consequences: bugs, slowdown, and morale
Code rot: small smells and what they look like
Rules and invariants you can rely on
How future you experiences code
Hidden dependencies and local reasoning
Start small, then scale the refactor
Keep it as simple as you can for as long as you can
Formatting and indentation for readability
Working code is not enough
Chapter 2 guided practice
A small end-to-end Strategy walkthrough
Reviewing branch-heavy code through a Strategy lens
When Strategy is overkill
When Strategy is the right call
Testing strategies cleanly
How Strategy relates to Factory and State
Common variants of Strategy
Refactoring towards Strategy, step by step
A second realistic example: shipping cost
The contract that makes Strategy work
How the Strategy pattern solves it
Why this is a problem worth solving
A specific example of the problem
The problem: one operation, many behaviours, one growing branch ladder
Behavioural patterns: an overview
Structural patterns: an overview
Creational patterns: an overview
What happens in the first 30 days after a custom build (without the fairy tale)
Why patterns matter (and when they don't)
The problem: everyone says 'pattern', nobody means the same thing
Practice and review
Regular expressions (introduction)
$_GET, $_POST, $_REQUEST, $_SERVER
Multi-site mess: it is the process, not the postcode
Arrays: practical operations
Arrays: basics
Functions
break and continue
When your 'temporary' spreadsheet becomes the business brain
for and foreach
while and do…while
match
When the tool stack feels heavier than the work
switch
Combining conditions and shorthand
Why a free systems review beats buying another subscription
if, elseif, else
Operators
Magic constants
Constants
Math helpers
Casting and type juggling
Numbers
String functions (starter set)
Strings: basics
Data types
echo and print
Variable scope (introduction)
Variables
Comments
PHP syntax: tags and statements
Install PHP and your first run
Characters
About PHP and this course
Superglobals (overview)
Smart user input classifier solution
Smart user input classifier exercise
Pattern matching with Option
Matching ranges
Adding conditional logic with match guards
Combining patterns
Matching with variables
Matching literals
Pattern matching with match
Nesting loops
Using ranges with the for loop
The for keyword
The while keyword
The loop keyword
Loop constructs
if and else statements
Control flow constructs
Enum methods
Destructuring enums
Matching with enums
Defining enums
Enums
Methods and associated functions
Struct initialization and update syntax
Unit structs
Tuple structs
Classic structs
Structs
Strings
Slices
Arrays
Tuples
Compound types
Booleans
Floating-point numbers
Integers
Scalar types
Data types and structures
Variable declarations and mutability
Shadowing
Mutable variables
Immutable variables
Step 3: Running the program
Step 2: Writing the calculator logic
Step 1: Setting up your project
Creating a library with cargo init --lib
Initializing a new Rust project with cargo init
Running your project with Cargo
Building your project
Cargo.lock: keeping dependencies consistent
Installing dependencies from Crates.io
Managing dependencies with Cargo.toml
Creating a new Rust project
Stable versus Nightly Rust
Cargo’s main features
What is Cargo?
Verifying Cargo installation
Compiling and running your Hello Rust
Hello Rust
Setting up VS Code for Rust (recommended)
Setting up your development environment
Verifying the installation
Installing Rust
Why learn Rust?
The Rust ecosystem
Key features of Rust
What is Rust good for?
About the course
Design Patterns: Memento
Design Patterns: Visitor
Avoiding Controller Bloat (In Laravel)
Laravel 101: The Basics
If AI Feels Like a Threat, Adapt
ORMs are great... until they aren't [Enhanced]
ORMs are great... until they aren't.
I'm gonna GIT you Sucka
OWASP: Web Security (Part 1 of 3)
Some coding quick wins
A way to deal with legacy systems
Interfaces and Abstract Classes
Building a service with me (part 4)
Building a service with me (part 3)
Build a service with me (part 2)
Build a service with me (part 1)
What is DRY?
Design Patterns: Composite
Returning Early
Design Patterns: Singleton
The market is broken (at least in Teesside)
Design Patterns: Bridge
We're Agile (In Name Only)
Some Quick Coding Tips
The Company-Wide Stand-Up: Corporate Delusion Edition
Design Patterns: Prototype
Design Patterns: Adapter
Ponds, Fishes and Software Engineering.
Being Both a Coder and a Parent
Design Patterns: Facade
Design Patterns: Decorator
Design Patterns: Strategy
Design Patterns: Chain Of Responsibility
How I landed a £30k contract.
The Problem With M-V-C
A little bit about DTOs
Coding Tips: Currying
The Interview Process Sucks (Sometimes)
Design Patterns: Builder
My Journey So Far
Design Patterns: Object Pool
DSA: Arrays and Linked Lists
Design Patterns: Fluent Interface
Design Patterns: Observer
The Coffee Shop Problem
Design Patterns: Factory
Collaboration and Real-Time Feedback
SOLID Principles: Dependency Inversion Principle.
What is code rot?
SOLID Principles: Interface Segregation Principle.
Legacy Code Is Everywhere.
SOLID Principles: Liskov Substitution Principle.
Companies Don’t Actually Care
Design Patterns: Command
SOLID Principles: Open / Closed Principle.
SOLID Principles: Single Responsibility Principle.
What happens if we train them and they leave?

Browse all insights

Every page on the site

Main pages

Insights

Teesside & the North East