The Scout’s Due Diligence Checklist: Spotting the 1% of Indie Prototypes That Won’t Fall Apart in Production

The easiest mistake an indie game scout can make in 2026 is falling in love with a 15-second vertical video on Twitter/X or TikTok.

Screen captures can be captured on an overclocked RTX 4090 workstation at 0.5x speed and interpolated to 60 FPS in DaVinci Resolve. Shaders can be stacked with full-screen bloom passes that look stunning in a dark dungeon clip, but collapse to 14 FPS the moment three enemy particle systems trigger simultaneously on a Steam Deck or a base Nintendo Switch.

Signing a game based on a video clip is how publishers end up burning half their advance on six months of emergency performance remediation.

Before our studio signs any co-development or publishing agreement, we run our prototypes through the exact same technical crucible we recommend to every publishing executive. Here is the five-point technical audit you should run before writing a Minimum Guarantee (MG) check.

1. The V8 / WebKit Garbage Collector (GC) Stress Test

The number one reason indie prototypes feel "micro-stuttery" on consoles and low-power handhelds is improper memory allocation inside the simulation loop.

Open the prototype in Chrome or Safari DevTools, navigate to the Performance tab, enable memory profiling, and record a 60-second gameplay run:

• The Red Flag (Saw-tooth Wave): If the heap allocation graph climbs rapidly and then violently drops every two to three seconds, the developer is instantiating new vectors, arrays, or anonymous callbacks inside their requestAnimationFrame or physics tick(). Each drop represents a Garbage Collector pause where the main thread freezes for 8 to 22 milliseconds. That will never pass console TRC (Technical Requirement Checklist).
• The Green Flag (Flat Allocation Baseline): The heap allocation stays virtually flat. The studio pools particle objects, reuses mathematical scratch vectors, and pre-allocates typed arrays during level initialization.

At Tegarama, every dynamic entity in Hitflag pulls from pre-allocated object pools. Zero allocations occur while the player is moving or capturing flags.

2. The GPU Budget: Draw Calls, Atlases, and Overdraw

A 2D or stylized 3D game should run effortlessly on integrated graphics (Intel Iris, Apple M-series, AMD Radeon 780M). If it does not, the culprit is almost always unbatched draw calls or irresponsible overdraw.

Inspect the WebGL context or run an APITrace / RenderDoc capture:

• Draw Call Threshold: A standard 2D arcade screen should rarely exceed 60 to 120 draw calls. If you see 1,400 draw calls for a simple scene, the studio is using individual texture files for every sprite instead of generating compressed texture atlases.
• Blending Overdraw: Layering 15 semi-transparent smoke or lighting quads over the entire screen destroys pixel fill rate on battery-constrained handhelds. Look for custom fragment shaders that accomplish volumetric effects with single-pass raymarching or procedural dithering rather than brute-force alpha blending.

3. Input Decoupling and Gamepad Abstraction

Many early-stage prototypes hardcode browser keydown listeners or window event handlers directly inside gameplay logic classes:

// The Rookie Pattern (Tight Coupling)
window.addEventListener("keydown", (e) => {
  if (e.key === "ArrowRight") player.x += 5;
});

If you see this pattern, porting the game to Steam Deck, DualSense, Xbox Gamepad, or mobile touch controls will require rewriting every single interaction script from scratch.

A production-ready prototype decouples raw input from intent through an action-mapping abstraction:

// The Production Pattern (Action Mapping)
interface InputState {
  moveX: number; // Normalized -1.0 to 1.0 from any device
  moveY: number;
  actionPrimary: boolean;
}

When this abstraction is in place, adding full gamepad support or mobile touch controls is a two-hour task, not a six-week refactor.

4. State Serialization (The Steam Cloud Test)

Ask the developer this simple question: "Can you pause the game right now, hit a key, and save the entire game state into a 50 KB JSON string that can be loaded on another device?"

If the answer is hesitation or "we haven't built the save system yet," danger lies ahead. In well-architected games, state is decoupled from rendering. The data model (player inventory, map coordinates, economy balances) lives in pure data structures, completely distinct from visual sprites or mesh instances.

In Kervan, the entire economic simulation state—including prices in 14 cities, active caravan inventories, and AI competitor routes—serializes into a compact 38 KB payload in under 2 milliseconds. This makes cloud sync, replays, and cross-save trivial.

5. The Commercial Deal: Fair Recoup Waterfalls

Technical diligence protects your engineering schedule; fair deal structures protect your balance sheet. In 2026, the traditional 100% publisher recoup waterfall is increasingly recognized as toxic for both sides.

When a publisher takes 100% of net revenue until their $150,000 MG is recouped, the developer earns $0 for the first several months post-launch. If initial sales are moderate, the studio runs out of cash, cannot support live ops, and abandons the game just when post-launch updates are needed to build long-term momentum.

We advocate for modern, aligned contract structures:

• The 60/40 Split Recoup: The publisher receives 60% of net revenue to recoup their advance, while the developer receives 40% from day one to fund live ops and community updates.
• Defined Milestone Kill Fees: If a prototype fails technical diligence at Milestone 2, the publisher can terminate with a predetermined kill fee that covers the studio's actual incurred burn, without legal ambiguity.
• Reversion Rights: If the publisher fails to market the title or commits less than the contractually agreed spend, publishing rights revert cleanly to the creators.

Partner With Studios That Respect the Metal

Great games are not born from marketing spreadsheets. They are built by teams who respect the hardware, profile their frame times, and write clean, modular architectures that scale from a web link to a living room console.

At Tegarama, technical diligence is not an afterthought—it is the foundation of our studio. Every project we share is audited, optimized, and ready for serious evaluation.

Let us examine prototypes together: hello@tegarama.com.