Expertise 01 / Game Architecture

Make the whole game easier to change

I design the technical foundation that connects game flow, gameplay, services, tools, and production without turning them into one coupled system.

01 / Scope

Architecture as
a working production system

New products

Define the lifecycle, composition model, ownership, module boundaries, developer entry points, test scenes, client/server responsibilities, and migration paths before accidental coupling becomes the default architecture.

Existing products

Trace actual game flow and dependencies, identify the smallest boundaries that restore control, and restructure incrementally. The objective is recovered development speed—not a rewrite for its own sake.

I stay hands-on through implementation because architectural decisions only become real when they survive gameplay requirements, debugging, performance constraints, content production, and late-stage changes.

02 / Diagnosis

The failures I look for
before they become expensive

Coupling without ownership

Everything depends on everything—even when a DI framework is present—and any feature can change global state from anywhere.

No product layers

Initialization, metagame, core gameplay, networking, and transitions have no explicit authority or lifecycle.

No isolation

A developer must boot the entire game and navigate manually before implementing, debugging, or testing a feature.

Accidental dependencies

Reusable systems accumulate game-specific hardcoding; assembly boundaries are absent; unrelated changes begin to travel together.

Optimization-hostile structure

Hot paths are organized around scattered object behavior rather than data flow and batch processing, so optimization first requires redesign.

Broad late-stage refactors

Large changes destabilize many systems at once. I learned to keep late-stage work small, isolated, and easy to verify after a broad final refactor required a week of stabilization at Wargaming.

03 / Method

Correct for the long term
Pragmatic for the release

  • Start with lifecycle and ownership. Make it explicit who creates, initializes, connects, reloads, reconnects, and shuts down every major system.
  • Make the unit of architecture independently runnable. Dedicated development and test scenes support implementation, debugging, manual cases, and automated tests without booting the whole product.
  • Prepare for change through boundaries, not speculative rewrites. I track Unity's direction and move code toward compatible data flow and responsibilities while preserving the current production workflow.
  • Keep migrations local. New architecture is introduced behind explicit seams rather than forcing the entire project and team onto a new model at once.
  • Respect the release horizon. Long-term-correct work often pays for itself before launch, but when a release is roughly two months away, shipping and contained fixes take priority.
Architecture is successful when ordinary feature work naturally follows the safe path

04 / Evidence

Applied across
new builds and project rescue

Cubic Games / Pixel Gun 2

Whole-game client/server lifecycle

Owned core architecture for a voxel multiplayer FPS.

  • Defined initialization, metagame, core gameplay, transitions, reloads, reconnects, and shutdown.
  • Structured services and DI around GameContexts.
  • Separated maps from game modes and established explicit server, client, and shared-simulation responsibilities.
  • Created ECS/NetCode-ready boundaries incrementally, while educating the team in ECS-oriented thinking and avoiding a project-wide rewrite.

Wargaming / REVOLT

Recovered a blocked client

Joined as client-team lead; rebuilding the architecture was the first major responsibility, not the whole role.

  • Stabilized the client and restored development flow.
  • Established reusable foundations for subsequent features.
  • Extended the work into a universal, fault-tolerant client/server command flow.
  • Continued across gameplay, optimization, technical art, and the wider lead role through production.

D.A.W.Studio / Four games

Reusable architecture without identical games

Designed four products from scratch: two online sniper games, a runner, and a roguelike shooter.

  • MC-VmV preserved the same application structure for single-player and server-backed products.
  • Reusable profiles, windows, asset bundles, battle quests, IAP, configuration, and gameplay foundations reduced glue code.
  • A team of three to four programmers delivered many features in about two days and complex UI in two to three.
  • Direct startup into the required state took roughly one to two seconds.

8D Studio / Sketch Tales

Architecture setup and planned handover

A predefined two-month engagement for a single-player voxel adventure.

  • Designed and implemented the core Unity architecture.
  • Built the part-based character-rendering system at the center of the game's visual concept.
  • Transferred ownership to the internal team as planned and advised through much of later production.

Earlier foundations

Architecture across engines and products

  • System architecture and client/server programming for World of Fishing at GoGames.
  • Technical direction for Seaker at West-Games using Unity Legacy Networking.
  • C/C++ runtime, C# editor, Managed C++ interop, game systems, and tool frameworks for S.T.A.L.K.E.R. 2.
  • A JSON scene model with object hierarchy, components, persistence, and game systems in a custom C#/XNA engine at Sonelly.

Flexy.Fun / Since 2010

Experience materialized

A personal engineering initiative, not another employment position.

  • Flexy.Bricks\ToYs defines an architectural methodology centered on modular, independently runnable units.
  • Flexy.Framework turns the methodology into a Unity-native foundation for composition, ownership, initialization, connection, and testing.
  • The approach is deliberately separated from game-specific code and supported by documentation, templates, GitHub packages, and free and paid Unity Asset Store packages.

05 / Outcomes

What the architecture
changes in daily work

1–2 sec

Start directly in a useful gameplay or test state.

2–3 days

Typical feature and complex-UI implementation cycles in a highly streamlined team.

Fewer bugs

Entire recurring classes of integration and reliability failures removed through boundaries and fault tolerance.

Local change

Reload, reconnect, migration, and optimization can evolve without restructuring the whole product.

06 / Relevant stack

Technologies used
in architectural work