Onboarding Contractors: A Game Developer's Survival Guide

How to get external collaborators productive in hours, not days

Read Time: 18 minutes

§Introduction: The Monday Problem#

It's Monday morning. Your new contractor, hired for a 3-week character art project, is sitting at their desk (or logging into Slack remotely). They're eager to work. They're expensive—$100+/hour.

What happens?

The chaos begins:

"Here's the Google Drive. The design docs are... somewhere in there. Oh, the latest stuff is in Notion actually. Or maybe the character sheet is in Figma? Let me find the link. Actually, ask Sarah—she'll know where things are. Sarah's in a meeting until 2 PM."

By Tuesday afternoon, your contractor is still piecing together what the project even is. By Thursday, they've asked 40 questions in Slack, interrupted 5 different team members, and finally have a rough understanding of what they're supposed to build.

Friday: They start actual work.

You paid for 5 days of productivity. You got 1.

This isn't the contractor's fault. It's your onboarding process—or lack of one.

§Part 1: The True Cost of Bad Onboarding#

The Direct Costs#

Contractor time wasted:

• —Day 1: 6 hours of "getting oriented"
• —Day 2: 4 hours of clarifying questions
• —Day 3: 2 hours of final confusion
• —= 12 hours at $100/hr = $1,200 per contractor

Team time wasted:

• —Sarah answered questions: 3 hours
• —Mike walked them through the codebase: 2 hours
• —Designer explained the vision: 1 hour
• —= 6 hours at $80/hr average = $480 per contractor

Total direct cost: $1,680 per contractor

If you hire 8 contractors per year: $13,440 annually

The Indirect Costs#

Quality impact:

• —Contractor works from incomplete understanding
• —Mistakes are made due to missing context
• —Revisions needed: 20-30% of deliverables

Timeline impact:

• —3-4 day delay on every contractor project
• —Deadline pressure increases
• —Overtime or scope cuts to compensate

Morale impact:

• —Contractors frustrated: "Why can't they give me clear info?"
• —Team frustrated: "Why do I always have to explain everything?"
• —Nobody wants to manage contractors

The Hidden Cost: Contractor Quality#

Good contractors have options. When they work with a chaotic studio, they remember. They charge more next time (chaos premium). Or they don't come back at all.

The studios known for "smooth contractor experience" attract the best talent. The studios known for chaos get whoever's available.

§Part 2: Why Onboarding Is So Hard#

The Knowledge Sprawl Problem#

Where does your project knowledge actually live?

Reality for most studios:

A contractor starting today has to discover all of this. There's no map. There's no index. There's no "start here."

The "Just Ask" Anti-Pattern#

Small studios develop a dangerous habit: "just ask [person]."

Why it develops:

• —Faster than writing docs
• —Docs get outdated anyway
• —Team is small, everyone's accessible

Why it fails at scale:

• —What if [person] is busy? Sick? Quit?
• —Contractors can't interrupt constantly
• —Same questions get answered repeatedly
• —Knowledge walks out the door when people leave

The Outdated Documentation Problem#

The docs that exist are often outdated. Contractors read them, trust them, and then discover reality differs.

"The design doc says player health is 100, but the game has 150. Which is right?"

Answer: The game. The doc is wrong.

But the contractor didn't know that. They built assets for 100 health. Rework needed.

§Part 3: The Contractor Onboarding Stack#

Layer 1: Project Overview (30 minutes)#

A single document that answers:

What is this game?

• —Genre, platform, target audience
• —Elevator pitch (1 paragraph)
• —Core fantasy/player experience

Where are we in development?

• —Current phase (pre-production, production, polish)
• —Ship target date
• —What's done, what's in progress, what's ahead

Who's who?

• —Team structure diagram
• —Key roles and responsibilities
• —Who to ask about what

How do we work?

• —Communication tools (Slack channels, email)
• —Meeting schedule (standups, reviews)
• —Work hours and time zones

This document should be 3-5 pages max. A contractor should be able to read it in 30 minutes and understand the project at a high level.

Layer 2: Role-Specific Context (1-2 hours)#

Different contractors need different information.

Character Artist:

• —Art style guide
• —Character design principles
• —Reference image collection
• —Technical constraints (poly counts, texture sizes)
• —Existing character library
• —Asset delivery format

Programmer:

• —Architecture overview
• —Codebase structure
• —Dev environment setup
• —Coding conventions
• —Key systems documentation
• —PR/review process

Level Designer:

• —Level design philosophy
• —Existing level library
• —Metrics (typical level size, enemy counts)
• —Tooling (level editor, validation tools)
• —Performance budgets

Audio Designer:

• —Audio style guide
• —Reference tracks
• —Technical requirements (formats, sample rates)
• —Implementation details
• —Asset naming conventions

Create a "starter pack" document for each role you commonly hire.

Layer 3: Specific Project Documents (2-4 hours)#

Links to the actual design docs, specs, and references for their specific work.

For a character artist:

• —Character brief for their assignment
• —Related character sheets (for consistency)
• —Approval workflow
• —Feedback/revision process

These should be easy to find—a curated set, not "here's our whole Drive, good luck."

Layer 4: First Task (Same Day)#

Give them something concrete to do on day one.

Not their main project—a small, well-defined task that:

• —Verifies they understand the workflow
• —Gets them creating something immediately
• —Builds confidence
• —Surfaces questions early

Example for artist: "Create a quick color study for [character]. Just concepts, 2-3 variations. Due tomorrow morning."

If they can complete this, they're ready for the main work. If they can't, you know they need more context before starting.

§Part 4: The Ideal Onboarding Flow#

Before Day 1: Pre-Boarding#

1 week before start:

• —Send access credentials (email, Slack, tools)
• —Send project overview document
• —Send role-specific starter pack
• —Include: "Read these before your first day. Bring questions."

1 day before:

• —Confirm their setup is working
• —Assign their first-day buddy (who to message for questions)
• —Schedule their first check-in meeting

Day 1: Orientation (4 hours)#

Hour 1: Overview meeting

• —Welcome, team introductions
• —Project vision (from creative lead)
• —Their role and expectations
• —Q&A on what they've read

Hour 2: Role-specific walkthrough

• —Tour of relevant tools
• —Review of their specific documents
• —Key contacts for their work

Hour 3-4: First task

• —Assign the small initial task
• —Make sure they know who to ask if stuck
• —Schedule check-in for next morning

End of day 1: Contractor has project context, knows where to find things, and has something to work on.

Day 2-3: Productive Start#

Day 2 morning:

• —Check-in meeting (30 min)
• —Review first task
• —Answer questions
• —Assign main project work

Day 2-3:

• —Contractor working on main project
• —Available for questions (but not constant support)
• —Regular async check-ins

By day 3, contractor should be largely self-sufficient.

Week 1 End: Retrospective#

Quick feedback session:

• —What was confusing?
• —What information was missing?
• —What could we improve for next contractor?

Use this to iterate your onboarding materials.

§Part 5: Building the Onboarding System#

Creating the Project Overview#

Template:

# [Project Name] - Contractor Overview

## What We're Building
[2-3 paragraphs on the game: genre, platform, target audience, core fantasy]

## Current Status
- Phase: [Pre-production / Production / Polish]
- Ship Target: [Date]
- Current Focus: [What the team is working on right now]

## Team Structure
[Org chart or list: Name, Role, What they handle]

## Key Contacts
- Creative questions: [Name]
- Technical questions: [Name]
- Production/scheduling: [Name]
- Your manager: [Name]

## Communication
- Primary: Slack #[channel-name]
- Meetings: [Schedule]
- Time zones: [Team's working hours]

## Getting Help
- First: Check documentation in [location]
- Then: Ask in #[channel]
- Escalate to: [Name]

## Document Locations
- Design docs: [Link]
- Art assets: [Link]
- Technical specs: [Link]
- Your project files: [Link]

Creating Role-Specific Packs#

For each role you commonly hire, create a document that includes:

1. 1.Style/approach guide for that discipline
2. 2.Technical requirements specific to their work
3. 3.Examples of good work from the project
4. 4.Workflow documentation (how to submit, get feedback, deliver)
5. 5.Tool-specific setup if needed
6. 6.FAQ specific to their role

Maintaining the System#

Onboarding docs decay like all docs. Fight this:

Quarterly review:

• —Is the project overview still accurate?
• —Are role packs still current?
• —Incorporate feedback from recent contractors

After each contractor:

• —What questions did they ask repeatedly?
• —What was confusing?
• —Update docs to address

Ownership:

• —Assign one person to own onboarding materials
• —Part of their regular responsibilities
• —Accountability for keeping it current

§Part 6: Gameframe-Specific Advantages#

Why Traditional Tools Fail for Onboarding#

Google Docs/Notion:

• —Good for writing the overview
• —Bad for: keeping it current, seeing what's changed, role-based access

File shares:

• —Good for: storing assets
• —Bad for: organization, knowing what's current, onboarding context

Scattered tools:

• —Each tool has its own permissions
• —No single "contractor view"
• —Hard to revoke access cleanly

How Gameframe Helps#

1. Single starting point

All project docs in one vault. Contractor gets one link. Everything they need is there.

2. Role-based visibility

Tag documents by role. Artist sees art-relevant docs. Programmer sees code docs. No overwhelming them with everything.

3. Version history for context

New contractor can see "what changed recently?" Understand the project's evolution, not just its current state.

4. Automatic expiration

Set access to expire when contract ends. No cleanup needed. Security by default.

5. Audit trail

See exactly what the contractor accessed. Useful for security review and understanding their work.

6. Linked documents

"This character spec links to the art style guide and the balance sheet." Context without hunting.

§Part 7: Common Onboarding Mistakes#

Mistake 1: Information Dump#

"Here's access to everything. Good luck."

Too much information is as bad as too little. Contractors don't know what's relevant. They waste time reading things that don't matter for their work.

Fix: Curate. Role-specific packs with only relevant docs.

Mistake 2: No First Task#

Contractor finishes reading docs. Then... waits. "So what should I do?"

Fix: Always have a small first task ready. Something they can complete in half a day that proves they understand the workflow.

Mistake 3: Assuming They'll Ask#

"If they have questions, they'll ask."

Many contractors don't want to seem incompetent. They struggle silently. They guess. They get things wrong.

Fix: Proactive check-ins. "What questions do you have?" Not "Any questions?" (which gets a "no" even when there are).

Mistake 4: No Feedback Loop#

Contractor leaves. Next contractor has the same problems. Nothing improved.

Fix: Collect feedback after each contractor. "What was confusing?" Then actually update the materials.

Mistake 5: Outdated Materials#

The onboarding doc was great... when it was written a year ago. Now it describes systems that don't exist.

Fix: Regular reviews. Ownership. Decay-resistant systems (version control).

§Part 8: The Onboarding Checklist#

One Week Before Start#

• —[ ] Send access credentials
• —[ ] Send project overview document
• —[ ] Send role-specific starter pack
• —[ ] Assign first-day buddy
• —[ ] Schedule day-1 orientation meeting
• —[ ] Prepare first task

Day 1#

• —[ ] Orientation meeting (1 hour)
• —[ ] Role-specific walkthrough (1 hour)
• —[ ] Tools/environment confirmed working
• —[ ] First task assigned
• —[ ] Check-in scheduled for day 2

Day 2#

• —[ ] Morning check-in (30 min)
• —[ ] First task reviewed
• —[ ] Main project assigned
• —[ ] Questions addressed
• —[ ] Independent work begins

End of Week 1#

• —[ ] Contractor working independently
• —[ ] Major questions resolved
• —[ ] Feedback collected
• —[ ] Onboarding materials updated based on feedback

§Part 9: Measuring Onboarding Success#

Metric 1: Time to First Productive Work#

How many hours/days until the contractor is doing their actual job?

• —Poor: 3+ days
• —Okay: 1-2 days
• —Good: 4-6 hours
• —Excellent: Same day

Metric 2: Questions in First Week#

How many "where do I find X?" or "what's the current Y?" questions?

• —Poor: 30+ questions
• —Okay: 15-30 questions
• —Good: 5-15 questions
• —Excellent: Under 5

Metric 3: First Deliverable Quality#

Does their first real deliverable match project standards?

• —Poor: Major rework needed
• —Okay: Some revisions
• —Good: Minor polish only
• —Excellent: Matches standards

Metric 4: Contractor Feedback#

At end of project, ask: "How was your onboarding experience?"

• —Poor: "Confusing, took forever to understand"
• —Good: "Smooth, I felt productive quickly"

§Conclusion: Onboarding Is a Mirror#

Here's the truth: contractor onboarding is a forcing function for documentation quality.

If a new person can't understand your project in 3 hours, your documentation is broken.

Not just for contractors. For new hires. For team members who switch focus. For future you, returning to a part of the project you haven't touched in months.

Fix your onboarding, and you fix your documentation. Fix your documentation, and everything else gets easier: fewer misunderstandings, less rework, faster iteration.

The studios with great onboarding:

• —Get contractors productive immediately
• —Attract better talent
• —Spend less time answering questions
• —Ship better games, faster

The studios with bad onboarding:

• —Pay contractors to be confused
• —Burn team time on repetitive explanations
• —Struggle with contractor quality
• —Have documentation debt they never repay

Build the system once. Maintain it. Iterate.

Your contractors will thank you. Your team will thank you. Your shipping schedule will thank you.

Related guides:

• —Contractor Access Setup - Configure role-based permissions for external collaborators
• —Documentation Decay - Understand why outdated docs cost studios millions
• —Version Control for Game Docs - Why proper version control matters

Ready to streamline contractor onboarding? Get started with Gameframe and give contractors exactly what they need.