LinnoEdge

LinnoEdge
Offshore Lab Development — Vietnam | Linnoedge
OFFSHORE LAB DEVELOPMENT · HO CHI MINH CITY

Translation wasn't
the problem.

Most offshore development projects that struggled didn't fail because of language. I've watched enough of them — from both sides of the table — to know where things break. Specs were signed. Code shipped. Something was still off, and nobody could articulate exactly what.

At one company I worked with, the lead engineer left in month four. The replacement had never touched the codebase. They recovered — but they lost three weeks, and that wasn't bad luck. There was no structure for when the team changed. The contract covered output. It didn't cover continuity.

The lab model was designed for that gap. Not a different contract — a different working structure. A dedicated team that stays accountable long after go-live, not just at handoff.

Book a Free Session

30 minutes. No cost. Comes with a written next-step summary.

Contact Us
If Any of These Sound Familiar

Three situations we see
most often before teams reach out

The details are always different. The underlying structure usually isn't.

A
The code shipped — but something's still off

You've shipped with an offshore team before. Specs were signed off. Code came in on schedule. The system runs — technically. But something in how it actually fits the workflow is wrong, and you're still not sure why. The team says it matches the spec. You know it doesn't fit how your people actually use it.

In almost every case I've seen, the spec captured what the system should do. It didn't capture what the people using it actually do — in what order, with what context, at what point in their day. That gap shows up at go-live, not before.

What naturally comes next
A Discovery phase before any code moves: one to two weeks of workflow observation — watching how the work actually flows, not just reading the spec. The lab team then builds to the observed reality, not the documented one.
B
A key person left mid-project

The lead engineer or PM left halfway through. The replacement was new to the codebase. You lost weeks you couldn't get back — and the project recovered, but you now know the delivery depended on specific people, not a structure. If it happens again, the outcome won't improve.

The lab model centers on knowledge continuity, not individual people. Every sprint generates documentation that a new team member can read into within a day. The IT Director holds the technical context across the full engagement — not any individual engineer.

What naturally comes next
A structured handover protocol built into the team's regular workflow from day one — not added after a departure. Documentation isn't a project deliverable, it's how the team operates.
C
The communication overhead is eating the project

Clarifications are taking longer than the development itself. Every spec change generates three more questions. The back-and-forth has become a project of its own — and you've started to wonder if the communication layer is the real problem, not the development.

It usually is. I've worked with clients who ran traditional offshore projects where the bridge engineer was converting technical questions into diplomatic ones — removing the friction, yes, but also removing the information. By the time the answer got back to the developer, it had been interpreted twice. The original question was usually still open.

What naturally comes next
A dedicated development team in Ho Chi Minh City — engineers who have shipped integrations for clients in Japan and Southeast Asia, with an IT Director who bridges the technical and business sides directly. No translation layer. Development costs land at roughly 30% of an equivalent Tokyo engagement. The difference: we don't hand off and disappear. QA checkpoint before anything touches your production environment. Ongoing support available from month one of go-live.
↳ field observation — week 11, B2B operations client I sat in on a review where the offshore team had built exactly what was specced — the warehouse status screen, six fields, three filters. The operations lead opened it on her phone and said: "this works for the day shift. We don't use phones at night — we have a printer at the dock." The spec didn't mention printers. The team didn't ask. We rebuilt the entire status flow in week 11.

Most offshore engineers don't know your business — they code what you spec, even when the spec misses how the work actually flows. The harder question — "is this a software fix or a workflow fix?" — usually nobody on the offshore team can answer.
The Difference

What separates a lab model
from traditional project outsourcing

The contract type matters less than what it commits to. Most offshore engagements optimize for delivery. The lab model optimizes for continuity.

You might ask: "Doesn't every good offshore team skip the bridge engineer by now?" The answer is no. Most still use one — for a reason. A bridge engineer absorbs cultural friction. That's real value, and it costs less upfront too. Our choice is different. We cut the coordination layer entirely. That means faster, more direct technical conversation — but also rawer. You get information without the diplomatic filter. Most teams find that's the right trade. But you should know what you're choosing before you choose it.

Traditional Project Outsourcing
Optimized for delivery
  • New team assembled per project — no accumulated context
  • Specs delivered, questions filtered through a coordinator
  • Knowledge disappears when the project ends
  • Accountability ends at handoff
  • Changes to scope trigger renegotiation delays
ACCOUNTABILITY WINDOW → go-live
VS
Linnoedge Lab Model
Optimized for continuity
  • Dedicated team — same people, same codebase, across months
  • IT Director works directly with your team — no filter layer
  • Knowledge documented sprint by sprint, survives team changes
  • Accountable from kickoff through post-go-live — not just at handoff
  • Mapped to actual workflow before a line of code is written
ACCOUNTABILITY WINDOW month 1+
Why Linnoedge

Three things that are different
about how this team works

No bridge engineer. I've worked with clients who've run traditional offshore projects before coming to us. Almost every time, the problem they described wasn't language — it was the person in between. The bridge engineer was converting technical questions into diplomatic ones. Removing the friction, yes, but also removing the information. By the time an answer got back to the developer, it had been interpreted twice.

Our IT Director is English-first, technically trained, and responsible for the output — not just the communication. When something is ambiguous, it surfaces immediately. Not after a two-day clarification cycle.

↳ observation — client engagement, Japan At one project, the bridge engineer was taking 48 hours to clarify a 20-minute question.
Not because they were bad at their job — because they'd been trained to minimize conflict,
not to surface technical disagreements.

AI-driven development environment. Every engineer on the team uses AI tooling as their primary working environment — Cursor, GitHub Copilot, Claude Code. Not as a project, not as an experiment. As the actual setup. A system that would have taken 14 weeks to build two years ago typically takes 9 or 10 now. That savings comes back to you in the budget or in scope.

Quality is a structure, not an attitude. At one engagement, we wrote the test plan before any code was written. Every feature came with a defined test scope attached to it. When requirements changed mid-project — and they always do — the test plan updated alongside the feature. Nothing reached production without passing that gate first.

Field note — client engagement, Japan
Test plan written before first commit Yes ✓
Production incidents at go-live 0
Scope changes mid-project 14
Deployment delays due to scope changes 0
Test plan updated with each scope change. Quality gate held regardless.

English-first team, Japanese-familiar context. Not every engineer on the team is a native English speaker. But every engineer on the core team has shipped integrations for three or more Japanese clients. They know what "it works to spec but doesn't fit the workflow" means. They know why a change in field labels can stall adoption for three weeks. That context saves months of back-and-forth that most offshore teams spend discovering it from scratch.

Ho Chi Minh City (GMT+7) overlaps with Tokyo (GMT+9) during standard business hours — plus a two-hour window in the afternoon. When something blocks, you get an answer the same business day.

Field note — mid-project, finance system rebuild
Trigger CFO changed discount calc logic mid-sprint
Default offshore reaction Push back on scope
Linnoedge IT Director's reaction Flagged tax-compliance risk
Outcome 3 weeks of rework avoided
Compliance risk caught before code Yes ✓
The CFO hadn't checked with legal. Engineering judgment alone wouldn't have caught it. Business-domain judgment did.

Most vendors will help
you ship.
Almost none of them are
still in the room
six months later.

Key Insight
What all three situations had in common: nobody had designed a structure that could survive change — in the team, in the requirements, or in the business itself.
Most vendors will help you ship. Almost none of them are still in the room six months later when the system works but the workflow around it doesn't.
3 Concerns

What comes up in almost
every conversation before committing

Regardless of company size, industry, or whether you've worked with offshore teams before.

01

Will the spec actually get built?

"We've had vendors sign off on specs, then ship something completely different. Nobody called it out until go-live."
Our Answer
Milestone plan in writing before we start. Not a Gantt chart — a written commitment: what ships by when, what the review checkpoint looks like, and what the exit condition is if the work isn't passing. We review the spec together at the start of each sprint, not just at kickoff.
02

What if key people leave mid-project?

"The last time a lead engineer left, we lost two months and ended up rebuilding half the project."
Our Answer
Every engineer documents as they go. The IT Director maintains a running technical context document throughout the engagement. If someone moves on, the replacement can read into the project in a day — not a week. The knowledge lives in the structure, not in any individual.
03

What if the vendor ships something unusable — or disappears?

"We've seen offshore projects go quiet after handoff. No one to call when something breaks six months in."
Our Answer
Three things that make this concrete, not a promise: Milestone plan in writing before we start. QA checkpoint before anything touches your production environment. Ongoing monitoring available from month one of go-live — not just at handoff.
Two Models

Choose how involved
you want to be

Both models use the same team. The difference is where the coordination layer sits.

Direct Model

Your PM communicates directly with our IT Director. No interpretation layer, no coordinator in between. Our IT Director functions as your technical PM — taking your direction, breaking it down for the engineering team, and escalating blockers before they become delays.

You see the sprint board. You're in the review calls. You're as close to the team as you want to be.

Good fit: Teams with an in-house PM who wants direct visibility without managing the engineering team themselves.
Full Engagement Model

Our Linnoedge PM joins from requirements definition through release. Handles spec design, stakeholder alignment, sprint planning, and cross-team coordination. You own the business context and review checkpoints. We handle the rest.

The first thing the PM does is spend time on-site — or on calls — understanding what actually happens in the workflow before a single line of code is written.

Good fit: Companies without a dedicated internal PM, or those where the internal team is already at capacity and needs someone to own the end-to-end.
How It Works

From first call to go-live
and beyond

The lab model starts before code. It doesn't end at deployment.

1
Discovery (1–2 weeks)
Before assembling the team, we clarify what we're actually building. This looks different depending on where you are: if you have a spec, we review it and flag gaps. If you don't, we spend a week observing the workflow and drafting one together. If you're starting from scratch, we scope a PoC with you and define what "done" looks like before committing to anything.
2
Team Assembly (2 weeks)
We build the team to match the actual scope — not a standard template. Minimum is PM + 1 developer. Most engagements run with PM + IT Director + 2–3 engineers. You meet the team before the sprint starts. If someone isn't the right fit for the project, we swap before anything begins.
3
Development (scope-dependent)
Two-week sprints. Review call at the end of each sprint — you see working software, not status updates. Every feature has a defined test scope before development starts. Scope changes don't require renegotiation; they require updating the sprint plan, which happens in the review call.
4
QA Gate → Release
Nothing reaches your production environment without passing a QA checkpoint. This isn't a final review — it's the gate the test plan was written for from day one. The release happens when the gate passes. Not on a schedule.
5
Ongoing (from month 1 of go-live)
The team is available for monitoring, iteration, and support from month one of go-live — not after a handover period. When something breaks, or when the system works well enough that the original scope no longer fits, the same team that built it is still in the room.
Pricing

How the cost works

Monthly fixed-rate contracts. No per-project bidding, no variable billing. You know the number before the sprint starts.

¥400,000 / ~$2,600 USD
per person, per month — minimum engagement: PM + 1 developer
  • Minimum team: PM + 1 developer — ¥800,000 / ~$5,200 USD/month
  • Typical team: PM + IT Director + 2–3 engineers — ¥1.6–2.0M / ~$10,000–13,000 USD/month
  • Discovery phase (1–2 weeks) billed separately before main engagement begins
  • Ongoing support after go-live available at the same monthly rate
  • Comparable Tokyo engagement: typically 2.5–3× the cost for equivalent seniority

The 30-minute session is free. If we agree to move forward, you'll receive a written estimate with team composition, scope, and timeline before anything begins. No commitment required before that point.

Cost Structure

Why this cost is sustainable

"Cheaper than Tokyo" is not a value proposition. Here's what actually makes this model work — and why it holds up.

Cost of Living

Senior talent at a different cost base

An engineer with 8+ years of experience in Ho Chi Minh City earns what a junior might in Tokyo. The talent isn't cheaper — the cost of living is. You get seniority without the Tokyo premium.

AI Tooling

Every engineer uses Cursor and Claude Code

A 14-week project runs 9–10 weeks now. That efficiency comes back to you — not as a margin increase on our side, but as a shorter engagement at the same monthly rate. Less time means less cost.

Accountability

We don't disappear at handoff

No post-launch chaos means no emergency bug fixes billed at 3× the normal rate. We absorb QA properly before it reaches you. The 30-day stabilization period is included in the engagement — not an upsell.

Selected Work

Three engagements,
what actually happened

Not descriptions of what we do — what happened at specific companies.

Healthcare · Japan
Web-based patient intake system — 14 locations
At a healthcare network in Japan, we built a web-based intake system to replace a paper-based process across 14 facilities. The constraint: staff had been using the same paper forms for over 20 years. A modern-looking interface would have been abandoned within a week.

We rebuilt the screen to mirror the paper form exactly — same field order, same layout logic. Added AI to three of the six fields. Nobody needed retraining. Go-live rolled out across all 14 sites in three weeks.
3 weeks to full rollout across 14 locations. 0 retraining sessions required.
Platform · Japan — 3 Years
Executive matching platform — built and maintained
At a platform serving senior executives, we built the core matching system from initial architecture through to an ongoing maintenance engagement now in its third year. The same team that built it is still maintaining it — same codebase, same IT Director, same accumulated context.

The requirement wasn't just to ship. It was to release something that could be iterated on over years without losing institutional knowledge every time the scope changed.
400,000 successful matches. 3 years, same team.
EdTech · Southeast Asia
AI-powered language learning platform
At an EdTech startup targeting language learners across Southeast Asia, we built the core learning platform and integrated an AI-powered assessment layer. The team operated across Japanese, English, and Vietnamese — no bridge engineer, no translation layer.

The AI assessment component was scoped as a PoC first — three weeks to a working prototype before full development was committed. The prototype defined the actual spec.
4 months from initial spec to regional launch. PoC → production.

Honest note

This is not the right fit if:

  • ×You need a team of 50 or more assembled immediately — we scale deliberately, not instantly
  • ×Your spec is fully locked and you're looking for the lowest bid to execute it without questions
  • ×You want to hand the project off entirely and not be involved in the process

This is the right fit if:

You want a team that understands what it's building

  • You've shipped with an offshore team before and something didn't quite fit — you want to understand why
  • Requirements are likely to evolve and you need a team that can handle that without resetting the contract
  • You want a vendor who is still accountable six months after go-live — not just at handoff
Free 30-min Session

In 30 minutes, let's find out
if the lab model is the right structure.

You've worked with an offshore team before — or you're considering it for the first time. Either way, the first question isn't about technology. It's about whether the structure we use will survive the reality of your project.

If anything on this page felt like it was describing your situation, that's enough to start. Use the 30 minutes to say it out loud. If this isn't the right fit, I'll tell you directly.

I'll ask you about
What's happened in previous offshore engagements — or what's making you hesitate about starting one. The specific thing, not a general problem statement.
I'll share back
What I've seen in similar situations, whether the lab model fits, and what the concrete next step looks like — whether that involves us or not.
1
Book a 30-min session via Google Meet — pick a time that works for your timezone
2
We talk through the situation — what's happened before, what you're trying to build, what the real constraint is
3
You leave with a concrete next step — defined in the session, not in a proposal deck that arrives two weeks later
Shogo Harada, CEO, Linnoedge
Who You're Talking To
Shogo Harada
CEO, Linnoedge — Ho Chi Minh City

I've been running development teams in Vietnam and India for over a decade. I know what breaks in offshore engagements — not from case studies, but from being the person who had to fix it. The failed handovers, the mid-project engineer departures, the specs that were technically correct but practically wrong.

The lab model is how Linnoedge's own internal development runs — and it's what we offer clients. Same structure, same accountability standard.

Based in Ho Chi Minh City. Working with companies in Japan, Southeast Asia, and globally.

FAQ

Common questions about offshore
lab development with a Vietnam team

Traditional project outsourcing optimizes for delivery: a defined scope, a fixed deadline, a team assembled for that project. Once delivered, the team disperses and the knowledge goes with them. Lab-type development uses a dedicated team assigned to your codebase over months — the same engineers, same IT Director, accumulating context sprint by sprint. Scope changes don't trigger renegotiation; they trigger a sprint plan update. Accountability doesn't end at handoff; it extends through go-live and ongoing.
Every engagement starts with a Discovery phase — 1 to 2 weeks of reviewing what exists and clarifying what "done" looks like before development begins. If requirements are genuinely unclear at the start, we scope a PoC first and use it to define the real spec. Once development is underway, scope changes are handled in the sprint review: we update the plan, update the test scope, and keep building. Nothing requires a contract renegotiation for scope changes below a defined threshold.
Every engineer documents as they go — code comments, architecture decisions, open questions. The IT Director maintains a running context document throughout the engagement. If someone needs to be replaced, the replacement can read into the project within a day. The knowledge is in the structure, not in any individual. In three years of running this model, we've had two mid-project engineer transitions. Both were absorbed without delivery delays.
From ¥400,000 / ~$2,600 USD per person per month. Minimum engagement is PM + 1 developer (¥800,000 / ~$5,200 USD/month). A typical engagement runs PM + IT Director + 2–3 engineers: ¥1.6–2.0M / ~$10,000–13,000 USD/month. For context, an equivalent team in Tokyo typically costs 2.5–3× that figure for the same seniority level. The 30-minute session is free. If we agree to move forward, you receive a written estimate with team composition, scope, and timeline before anything begins.
English is the team's primary working language. No bridge engineer, no translation layer — the IT Director communicates directly with your team in English. Ho Chi Minh City (GMT+7) overlaps with Tokyo (GMT+9) by standard business hours, and has a 2-hour overlap window with the early part of European business hours. For US-based clients, we set up async workflows with a daily sync call. Time zone differences have not been a blocking factor in any engagement we've taken on.
From the first session to first sprint: typically 2 to 4 weeks. Discovery takes 1–2 weeks, team assembly runs in parallel for the second week. You meet the team before any sprint begins. The total onboarding period — from booking the first session to writing the first line of code — has averaged 18 days across our last six engagements.
Web systems (React, Next.js, Node.js, Python, PHP/Laravel), mobile apps (iOS Swift, Android Kotlin, React Native), AI integrations (OpenAI, Gemini, Claude, Azure AI, LangChain), and PoC/MVP development. For embedded and automotive systems, we work with an India-based team. We don't claim to do everything — if the project requires a technology outside our current team's depth, we'll tell you in the first session.