Outsource Three.js Development: How It Works

Deciding to outsource Three.js development is the easy part. The part that goes wrong is the operations: who has repo access, how the client sees progress without meeting the developer, how updates flow across a timezone gap, how the work invoices, and what actually gets handed back at the end. Get those wrong and a brilliant 3D build still feels like a bad engagement. Get them right and your studio runs a senior WebGL specialist as smoothly as an internal hire — under your brand, on your process.

I'm Hon Tran, a creative developer and Awwwards jury member who has run this exact model with studios across Norway, Denmark, Sweden, Malta, and the US for 11+ years. This is the operations playbook: the contracts, tooling, comms rhythm, and handoff artifacts that make outsourced Three.js work feel invisible to your client. If you're still deciding whether to partner, start with white-label WebGL development without an in-house hire; this post is the how.

Step 1 — NDA and white-label terms, before any brief

Nothing moves until two documents are signed. First, a mutual NDA — the client's identity, the brief, and the design files are confidential in both directions. Second, a white-label agreement that spells out three things explicitly:

• I don't publicly claim your client or display the work without your written permission.
• All deliverables, repositories, and derived assets are yours on final payment.
• My name stays off public credits unless you choose to add it.

Agencies need this in writing, not on trust, and I treat it as non-negotiable. It's the foundation the whole engagement stands on — the client should never be able to tell there were two studios in the room.

Step 2 — Scoping: separate the standard, the hard, and the spike

You send the Figma, the motion references, and the intent. I come back with a scope that splits the work into three honest buckets:

• Standard — layout, responsive behaviour, known GSAP patterns. Predictable.
• Hard — a bespoke shader, a GPGPU particle system, a scroll-driven camera rig. Doable, but it takes real time.
• Research spike — an effect I need to prototype before I can estimate it. Some are three days; some are three weeks. I flag these so your pitch never promises a timeline I can't hold.

You get a fixed estimate per phase, not an open meter. That lets you quote the client with confidence and protects your margin. For setting the client's budget expectations up front, point them at what an animated, motion-heavy website costs.

Step 3 — Repo access and environments

This is where most outsourced engagements leak. The clean setup:

• Repo — I work in your GitHub/GitLab org on a feature branch, or in a fresh repo I hand to you. Either way you own it. Commit hygiene, a clear branch strategy, PRs your team can review.
• Staging — every push builds a Vercel/Netlify preview URL you forward straight to the client. They review the real thing on real devices; you never have to screen-share my machine.
• Secrets — env vars live in the hosting dashboard, never in the repo. If the 3D pulls from a CMS, I get a scoped, revocable token — not your production keys.

# The rhythm the client actually sees: every push = a fresh preview link.
git push origin feature/webgl-hero
#  ↳ Vercel builds → https://your-studio-git-webgl-hero.vercel.app
#    You forward that link. The client reviews. Your brand on the URL.

The point: the client experiences your studio's staging pipeline. The developer behind it is invisible infrastructure.

Step 4 — Communication cadence across the timezone

I'm in Ho Chi Minh City (GMT+7) and run async-first with EU, Middle East, and US studios. The offset is a feature, not a bug — I hand off progress while your team sleeps, so mornings start with something new on staging. The rhythm that works:

Channel	Used for	Frequency
Written daily update (Slack Connect / email)	What shipped, what's next, any blockers	Every working day
Loom walkthrough	Motion & 3D review — the only reliable way to review animation async	Per milestone
Shared board (Linear / Notion / Trello)	Scope, phase status, decisions log	Live
Scheduled overlap call	Kickoff, milestone sign-offs, unblocking	As needed, in your morning

Motion can't be reviewed over a static screenshot — you have to see it move. A 90-second Loom of a scene reacting to scroll gets better feedback than an hour-long call, and it's on record. That's why the review artifact is a video, not a screen-share you have to attend live.

Step 5 — Invoicing and how the money flows

The client pays your studio; you pay the partner. Nothing about the money touches the client relationship. Typical structure:

• Deposit to start a phase (commonly 40–50%), balance on phase acceptance.
• Fixed per-phase, so your quote to the client has a known cost of goods underneath it.
• In USD, remote, standard international invoicing — no surprises.

Because scope is fixed per phase, you always know your margin before you commit the client. Change requests are their own line, quoted before work starts — the number-one cause of margin erosion is unquoted "small tweaks" that pile up.

Step 6 — Handoff: what you actually get back

The engagement ends with a package your team can own without calling me forever:

• The repo, documented — readable Three.js/R3F components, commented shader uniforms, defined breakpoints.
• A short architecture Loom — how the scene is structured, where to change what.
• Reusable utilities — the animation/WebGL helpers, so the next project starts ahead.
• A launch window — I stay available through go-live, and offer a maintenance retainer if you want one. Most agency partners take it, because the next pitch tends to need the same firepower.

That maintainability is the line between a white-label partner and a lock-in vendor. You should never be hostage to the person who built your 3D. To see the standard the handoff is held to, browse the projects archive.

The operations checklist

Before you outsource a Three.js build, confirm all of these are agreed in writing:

• Mutual NDA + white-label agreement signed
• Repo ownership and access defined
• Staging/preview pipeline the client can see
• Written daily update + Loom review cadence
• Fixed per-phase scope and payment schedule
• Change-request process (quoted before work)
• Documented handoff + optional retainer

FAQ

Can you work inside our existing codebase and conventions?

Yes — your Next.js/React setup, your linting, your branch strategy. If you don't have conventions yet, I'll set up a clean, maintainable foundation your team owns after handoff.

How do you review animation asynchronously?

Loom. Motion has to be seen moving — a recorded walkthrough of the scene reacting to scroll gets sharper feedback than a live call and stays on record for the whole team. Static screenshots don't work for 3D.

Who owns the code and the IP?

You do, on final payment — repo, assets, and derived work. That's written into the white-label agreement before anything starts.

What size engagements make sense to outsource?

Anything from a single WebGL hero or microsite to a full award-targeted build. If you're weighing the partner route against hiring or a full agency, see creative developer vs agency vs template vs Webflow, and the questions to ask before hiring a creative developer.

Run a senior WebGL specialist under your brand

If you want the operations to feel invisible to your client — NDA-ready, timezone-friendly, fixed scope, documented handoff — that's how I work with studios. Send the brief on the hire page, or see the work first in the projects archive. Your studio owns the client; I make the Three.js run like clockwork underneath.