George Wall ®
George Wall London Full-stack systems · developer tooling

Full-stack engineer · 10+ years in fintech

Production bugs belong in the editor

I build React and TypeScript products, .NET systems and iOS apps — then write the Roslyn analysers that move failures from late-night incidents to a precise line of code.

See the evidence GitHub

Failure distance

Move the catch closer to the author.
Live trace
LINQ001 Caught at source 
db.Orders.ToList().Where(...)

Filter in the database before materialising the result.

The same fault; a radically shorter feedback loop.

Open-source adoption
159K+ NuGet downloads
Product range
2 App Store releases
Delivery context
10+ years in fintech

Selected interceptions

Three failures that never made it out.

Most of the open-source work sits just before the mess: analysers, source generators and CLIs that make bad code complain early, where it is still cheap to fix.

LINQ001 intercepted

Compile-time safety · EF Core

LinqContraband

A Roslyn analyser that reads your LINQ the way the database will. N+1 queries and client-side evaluation get caught in the editor, not after a slow page has annoyed everyone.

LINQ001

Materialising before filtering pulls the whole table into memory.

Before 
                db.Orders
  .ToList()
  .Where(o => o.Total > 1_000)
Quick fix 
                db.Orders
  .Where(o => o.Total > 1_000)
  .ToList()

The database filters; the editor catches the expensive shape before review.

45,272 NuGet downloads v5.7.1 C# ★ 9 Updated 2 days ago
  • analyzer
  • code-analysis
  • csharp
  • dotnet
  • ef-core
  • ef-core-performance
Install package GitHub
DILIFETIME001 intercepted

Compile-time safety · DI

DI Lifetime Analyzers

Captive dependencies, leaked scopes, lifetime mismatches: the bugs that look fine in tests and then embarrass you under load. This catches them while you type, with zero runtime overhead.

DILIFETIME001

A singleton captures a scoped dependency and quietly extends its lifetime.

Before 
                AddSingleton<ReportService>()
AddScoped<AppDbContext>()
Quick fix 
                AddScoped<ReportService>()
AddScoped<AppDbContext>()

The container graph becomes a compile-time contract instead of a runtime surprise.

27,207 NuGet downloads v3.5.20 C# ★ 10 Updated yesterday
  • aspnetcore
  • best-practices
  • bug-detection
  • captive-dependency
  • code-quality
  • compile-time
Install package GitHub
CANCEL001 intercepted

Compile-time safety · async

CancelCop

A focused analyser for CancellationToken propagation across handlers, EF Core, HTTP and Minimal APIs. Cooperative cancellation, enforced, with code fixes that wire the token for you.

CANCEL001

A cancellation token reaches the handler, then disappears at the database call.

Before 
                Task Handle(CancellationToken ct)
  => db.SaveChangesAsync();
Quick fix 
                Task Handle(CancellationToken ct)
  => db.SaveChangesAsync(ct);

The code fix wires cooperative cancellation through the whole call chain.

35,087 NuGet downloads v1.38.0 C# ★ 4 Updated today
  • aspnet-core
  • async-await
  • cancellationtoken
  • code-fix
  • csharp
  • dotnet
Install package GitHub
Explore every project

Writing

Notes from the failure boundary.

Practical essays about the bugs that escape tests, the tools that catch them, and the decisions hidden inside “it works”.

  1. 01

    Compile-time safety · HTTP resilience

    When HTTP retries make failures worse

    Retries can rescue a transient request—or multiply load, latency and side effects. The difference is a policy the code can explain.

    7 min read
  2. 02

    Compile-time safety · configuration

    Catching broken appsettings before deployment

    How .NET Options and appsettings drift apart, and how to move missing sections, bad values and validation gaps into the editor.

    7 min read
  3. 03

    Compile-time safety · EF Core

    Catching N+1 queries at compile time

    Why N+1 and client-side evaluation survive code review and tests—and how a Roslyn analyser moves the catch into the editor.

    6 min read
Visit the writing desk

iOS products

From first tap to App Store.

Two games live, a third product in App Store review. I design the systems, build the interfaces, make the store art, and carry each release through the unglamorous final mile.

Live now
02
In review
01
GemGame App Store artwork showing a large cascade on the redesigned jewel board
Cascade system
GemGame App Store artwork showing striped, wrapped, seeker, and rainbow power gems
Power gems · v2.1

Shipped iOS game · Match-3

GemGame: Cosy Match 3 Puzzle

App Store v2.1.2

A hand-built match-3 game with big cascades, expressive power gems, ten galaxy worlds, and no ad sludge. Version 2.1 sharpens the jewels and makes every special feel properly explosive.

  • SpriteKit
  • SwiftUI
  • Game Center
  • StoreKit 2
App Store Game info FAQ Support Privacy Terms
Fleet Commander App Store artwork showing the connected galaxy frontier map
Connected galaxy
Fleet Commander App Store artwork showing tactical gambits before a border battle
Tactical gambits

Shipped iOS game · Strategy

Fleet Commander

App Store v1.0.5

A compact space strategy game about reading a connected galaxy, choosing where to expand, and holding the frontier. Fleets, tactical gambits, research, offline progress, and prestige all made the launch build.

  • Swift
  • Game Center
  • StoreKit
  • iOS 17+
App Store Game info Support Privacy Terms
NoBooze App Store artwork showing a 128-day alcohol-free streak on the daily dashboard
Streak & milestones

Submitted · Health & Fitness

NoBooze

In review v1.6.0

A private, science-backed sobriety companion built to make progress feel tangible without making a difficult day feel like failure. Streaks, health milestones, check-ins, journalling and slip support in one calm SwiftUI experience — now finished, signed, and sitting in App Store review.

  • SwiftUI
  • Core Data
  • CloudKit
  • StoreKit 2
  • WidgetKit
Product site

About

I make the dull guarantees that let teams move quickly.

I’m George, a full-stack engineer with ten years in London fintech — calculation engines that price pension liabilities, React/TypeScript frontends built from scratch, and the engineering standards that keep big teams shipping. Correctness really matters in that world, and it’s shaped everything I build.

I work the whole stack by preference, not necessity: the Kafka consumer, the C# engine it feeds, the React grid that makes the numbers legible. And I’m drawn to the unglamorous infrastructure of quality — the analyser that flags a captive dependency, the generator that deletes a thousand lines of boilerplate, the CLI that moves a solution without making a mess.

Good software fails loudly, early, and somewhere cheap to fix. I spend my time moving the failure as close to the keyboard as it’ll go.

Across .NET, TypeScript and Swift, the through-line is the same: move the surprise earlier, make it obvious, and keep production out of it.

Working with

  • C#
  • .NET
  • Roslyn
  • Kafka
  • EF Core
  • TypeScript
  • React
  • RTK Query
  • Swift
  • SwiftUI
  • Rust
  • Azure
  • Docker