Nearshore Software Development for US Agencies: Capacity Without Headcount

The three ways an agency adds capacity

Most agencies do all three at once, and the mistake is not choosing wrongly, it is choosing by reflex. The arithmetic below is the part that usually goes unexamined.

The arithmetic of a hire against overflow capacity

The numbers an agency already tracks are the ones that decide this.

A US-based developer costs, fully loaded, well above salary: the median US software developer wage is USD 135,980 (BLS, May 2025 data), and a benefits and overhead load on top of that is what you actually carry. Against that, billable utilization across professional services averaged 66.4 per cent in 2025, a record low, with top performers near 75 per cent and the highest-maturity firms at 81.2 per cent (SPI Research benchmark). Small agencies of one to ten people typically target 70-85 per cent.

So the real question is not "can we afford another developer" but "how many months of the year can we keep them billable". The formula:

Break-even utilization = fully loaded annual cost of the hire ÷ (billable hours available × your effective billable rate)

If the pipeline supports utilization above that threshold reliably, hire. If it supports it in good quarters only, the fixed cost is a bet on your own forecast, and forecasting is exactly what agencies do worst, because the client decides.

Overflow capacity inverts the risk. You pay for it while the work exists, and it stops when the work stops. What you give up is control over the person's long-term development and, if you handle it badly, continuity on the account.

One cost worth naming because it is invisible on a spreadsheet: hiring takes management attention at exactly the moment the pipeline is busy. Technical hires at companies under 25 people take 42 days with a recruiter and 62 without (Ashby, February 2026): a delivery director running a search is a delivery director not running delivery.

When nearshore is the wrong answer

Four situations where an outside engineer will not help, stated plainly because you will find them out anyway.

• Work under about a hundred hours. Onboarding a person into your codebase, tools and client context costs real time. Below that threshold your own team, or a specialist freelancer who needs no context, is cheaper.
• A deep specialism you cannot evaluate. If nobody at your agency can review the work, you are outsourcing judgement, not capacity. That fails regardless of who you hire.
• Clients who contractually require onshore staff. Government, some healthcare, some defence-adjacent work. Read the master services agreement before promising anything.
• An agency with no technical lead. The model depends on someone owning architecture and code review on your side. Without that, an outside team makes decisions you inherit and cannot defend.

What it costs, by region

Two things to notice. Latin American rates fell 7.1 per cent year on year in 2025, which means quotes from eighteen months ago are no longer the market. And the spread inside each band is wider than the gap between bands: seniority and domain fit move the number more than geography does, which is why comparing a rate without comparing the person is a mistake agencies make repeatedly.

Embedded engineers start at about USD 32 an hour; experienced engineers and architects run USD 50-60, month-to-month or committed. It is lower than a US rate because of geography, not a lower bar: every engineer passes the same assessment, has 5+ years in production and C1 English.

Time zones, language and the working day

This is the difference between nearshore and offshore in practice, and it is not a marketing point, it is a measured effect on delivery speed.

Brazil runs one to two hours ahead of US Eastern for most of the year, which means a full overlap with an East Coast working day and a substantial one with the West Coast. The team works 10:00-19:00 Brasília time: 9:00-18:00 Eastern from March to November (8:00-17:00 in winter) and 6:00-15:00 Pacific: a full East Coast day and about six hours with the West Coast.

Why overlap matters more than it sounds: a code review that happens the same day keeps a pull request moving; one that waits twelve hours turns a two-day task into a week. Herbsleb and Mockus measured this in IEEE Transactions on Software Engineering and found that work spanning sites takes significantly longer than the same work in one place, driven by communication and coordination delay (reference). Espinosa and Carmel modelled the same effect specifically as a function of time separation, showing coordination cost rising as overlap falls (HICSS 2003). Carmel and Agarwal's earlier work in IEEE Software catalogued the tactics that reduce it: liaison roles, deliberate overlap hours, and rotation (IEEE Software 18(2)).

The practical translation for an agency: same-day review, one named counterpart, and a standup the outside engineer actually attends. Those three things recover most of the distance penalty, and they cost nothing.

On language, the EF English Proficiency Index publishes country-level scores annually and is the neutral reference to cite rather than a vendor's own claim. What matters operationally is not test scores but whether the engineer can run a client call, and that is an interview question, not a country statistic.

How an outside engineer works under your brand

This is the question agencies actually ask and nobody answers in public. The answer is that the engineer works inside your operation, and how they are presented to your client is your decision.

What that means concretely:

• Your tools. Your Slack, your Jira or Linear, your repository, your CI. Not a parallel system that reports in weekly.
• Your process. Your sprint cadence, your definition of done, your code review rules, your pull request template.
• Your standups. The engineer attends, in your working hours, and speaks.
• Your technical lead reviews the work. Not as a formality: this is the control that makes the whole model safe.
• Client-facing presence is your call. Some agencies introduce the engineer by name as part of the team; some keep all client communication with the account lead. Both work. What does not work is improvising it after the client asks who wrote the code.

The decision worth making deliberately, before the engagement starts, is which of those two you want, and then briefing the engineer accordingly, including on what they say if asked directly. Agencies that handle this in advance never have an awkward moment; agencies that do not, eventually do.

What that looked like on one engagement. A US agency partner brought us in through staff augmentation on a project where three vendor teams were working without clear ownership, and delivery was stalling. When they escalated it to every CEO in the room, we stepped in: we took over cross-team coordination, aligned the teams on a shared cadence and unblocked execution. Delivery picked up within the first two weeks.

The client saw our engineer under the agency's brand, with an agency email address, as part of the agency's team. At one point, on short notice, we went to an on-site demo event for the client, and the demo was delivered as planned. Since then we have shipped a running increment of the software every week, and we are still on the account.

The relationship grew from there. Two more projects were awarded to our team within two weeks, and an experienced ByteNana tech lead now supports nearly all of the agency's projects.

Engagement models and what each one suits

A caution on the third. Fixed scope looks like risk transfer and behaves like a negotiation when requirements move, and in agency work the end client moves them. Empirical research on outsourced software contracts finds contract type systematically shapes vendor behaviour and outcomes (Gopal et al., Management Science, reference). Use fixed scope where the scope is genuinely fixed, and time and materials with a shared scope document everywhere else.

The contract terms that decide whether this works

Six clauses matter more than the rate. Read them before signing, and ask for them in writing if they are absent.

That list is the short version; the full treatment is in a separate piece on nearshore contract clauses, which covers what happens to the repository if the relationship ends. Our standard agreement already covers IP assignment to the client, white-label delivery, and month-to-month or committed terms.

One point of knowledge transfer worth stating, because it is the failure agencies report most: when an engagement ends, what leaves is context, not code. Research on distributed development identifies knowledge sharing and social ties as a primary determinant of collaboration success (Kotlarsky and Oshri, European Journal of Information Systems, reference). The practical protection is documentation written during the work, not at the end of it.

Week one, and how to tell it is going well

• Day 1: access to repository, CI, issue tracker, staging environment, and the client's design files. Nothing productive happens before this, and it is the most common reason week one is wasted.
• Days 2-3: one small real ticket that ends in a merged pull request. Not a sample task: something in the actual codebase.
• Day 5: the engineer has attended every standup, asked at least one useful question about the client's domain, and knows who to ask what.
• Week 2: a written definition of done for the current milestone, agreed between your lead and the engineer.
• Day 30: they are picking up tickets without being briefed line by line, and your lead's review comments are about design rather than about conventions.

If day 30 does not look like that, the problem is almost always access, ambiguity or the absence of a named counterpart, in that order, and all three are yours to fix rather than the engineer's. Week one: access to repo, tickets and Slack on day one, a first small ticket merged by day five, a written check-in at the end of the week. What most often goes wrong: access requests sit in the agency's IT queue for days.

Frequently asked questions

What is nearshore software development, and how is it different from offshore?

Nearshore means a delivery team in a country within a few hours of your own working day: for US agencies, usually Latin America. Offshore means five to twelve hours of separation. The difference is not the rate; it is whether a code review happens the same day, which measurably affects how long work takes.

How much do nearshore developers cost per hour in 2026?

Latin American senior developers run USD 60-75 an hour and juniors USD 33-45, per Accelerance's November 2025 rate guide, with regional rates down 7.1 per cent year on year. US architect-level onshore rates run USD 140-210. Seniority and domain fit move the number more than country does.

Can a nearshore team work under our agency's brand with our clients?

Yes. The engineer works in your tools, your sprint process and your standups, and how they are introduced to your client is your decision: named as part of the team, or all client communication through your account lead. Decide before the engagement starts and brief the engineer accordingly.

Who owns the code our nearshore team writes?

You do, if the contract says so. Require IP assignment covering source, build scripts, test fixtures and documentation, and require that the work happens in your repository from day one rather than being transferred at the end.

How fast can a nearshore engineer be productive on our stack?

Access on day one, a small real ticket merged in the first three days, and unsupervised ticket pickup by day 30 is a reasonable standard. When it is slower, the cause is usually missing access or an unclear definition of done. Our own median is 5-7 working days.

What happens if our client project ends early?

That is the ramp-down clause, and it should be agreed before you start: notice period, handover documentation, and who pays for any overlap. Your supplier's notice period must not exceed what your own client contracts allow you to promise.

The short version

• The choice is between a fixed cost (hire), an idle cost (bench), and a variable one (embed).
• With billable utilization averaging 66.4 per cent in 2025, a hire is a bet on your own pipeline forecast.
• Overlap hours, not rates, are what separate nearshore from offshore in delivery speed.
• The engineer works in your tools and process; client presentation is your decision, made in advance.
• Six contract terms decide the outcome: IP assignment, repository ownership, notice period, ramp-down, NDA flow-through, non-solicit.
• It is the wrong answer below about a hundred hours of work, or without a technical lead on your side.