Arc.dev contract and cancellation: Exit clauses and switching costs

Local hiring costs $150,000-$200,000 fully loaded per senior developer annually, which drives engineering leaders to platforms like Arc.dev. But the most important clause in your developer contract isn't the headline hourly rate. It's what happens when things go wrong: the friction and cost of leaving when a developer underperforms, a project ends early, or your company's needs change. This is a breakdown of Arc.dev's cancellation policies and switching costs, compared against our rolling-contract model, so you can run the numbers before you sign.

Arc.dev contract: Duration & your obligations

Understanding what you're committing to on entry matters as much as knowing how to exit. Before you can accurately model switching costs or evaluate cancellation terms, you need a clear picture of your obligations from day one: what contract structures are available, how long you're financially exposed, and which terms are visible before you sign versus after.

Choosing your Arc.dev contract type

Arc.dev operates two engagement models with different contractual obligations. The freelance model connects you with hourly developers for project-based work. The full-time placement model sources a permanent hire who becomes your employee, for a 20% upfront placement fee. Exit terms for freelance engagements are governed by a Freelancer Sourcing Agreement incorporated into Arc.dev's Terms of Service, but this agreement is not publicly posted and is not available to review before you enter the sign-up process. For a CTO evaluating vendor lock-in risk, this opacity is a material data point.

Arc.dev engagement term lengths

Arc.dev doesn't publish fixed minimum engagement durations for freelance contracts in its publicly available materials. Project timelines are typically agreed between client and developer at the engagement start. Arc.dev does provide a trial period for new engagements. The exact duration by engagement type is not confirmed in publicly available materials; verify current trial terms directly with Arc.dev before signing. But the detailed exit obligations beyond that window are governed by the Freelancer Sourcing Agreement, which is not available in full before you sign.

For full-time placements, the 20% placement fee is a one-time upfront cost, and the developer joins your payroll. The ongoing relationship with Arc.dev continues under their platform terms, which governs your account and the non-solicitation clause covering that developer.

Minimum spend for Arc.dev

Arc.dev does not publish a specific minimum spend threshold for ongoing engagements in publicly available materials. Reported developer hourly rates on the platform fall between $60 and $80 at the time of publication. This does not reflect Arc.dev's platform fee on top. The all-in cost to you is higher than the developer's take-home rate, and the exact markup percentage is not disclosed upfront, which makes budget modeling difficult before final interviews.

Arc.dev agreement termination requirements

Here's what to expect when terminating an Arc.dev engagement: what you owe, how long you're bound, and your options if a developer underperforms.

Minimum notice for Arc.dev exit

Arc.dev's Terms of Service specifies a written notice requirement to terminate your platform account. The exact notice period is not confirmed in publicly available materials; verify the current requirement directly with Arc.dev before signing. This notice applies to your Arc.dev relationship, not to individual developer engagements. The termination terms for specific contracts may be governed by supplementary agreement documents referenced within Arc.dev's platform terms. Full agreement details may not be publicly accessible before signing.

Ending Arc.dev contracts early

Arc.dev's publicly available Terms of Service do not document a specific early-termination penalty for freelance engagements, and the 20% placement fee for full-time hires is paid upfront rather than structured as a cancellation charge. The absence of a published fee doesn't equal the absence of financial exposure. The public terms explicitly note that master-agreement termination does not affect existing Statements of Work, meaning the specific obligations you owe if you exit early live inside the individual SOW you sign - and those terms may not be visible until the contract is in front of you. As our guide on staff augmentation contract terms explains, your most important negotiation leverage exists before you sign, not after a project goes sideways.

Replacing underperforming devs

Arc.dev backs their vetting process with a replacement guarantee: if you're unsatisfied, notify Arc and they'll match you with another candidate at no extra cost. The guarantee covers overall fit and satisfaction during the initial trial period. The exact trial duration and eligibility conditions vary by engagement type; verify these terms directly with Arc.dev before signing.

Guarantee: What's covered & excluded?

Arc.dev's risk-free trial covers your overall satisfaction and fit with the developer during the initial engagement period. What it typically doesn't include is pausing your broader platform relationship while you evaluate a specific developer. If you need a replacement, you restart the sourcing process while your engineering roadmap sits idle.

Compare this to a model where replacement terms are defined upfront. Cloud Employee's 7-day sourcing process delivers CTO-vetted candidates within one week of a requirements call, and our free replacement guarantee isn't limited to an undefined trial window. Coordination overhead still exists across distributed teams even with structured handoffs, and full codebase context takes time regardless of vetting quality.

Arc.dev fees: Unpacking your total spend

Arc.dev's fee structure operates across two distinct models, each with different payment timing and ongoing financial obligations. One-time fees affect your upfront capital allocation; recurring platform markups affect your monthly burn rate. Knowing which costs fall into which category determines how accurately you can forecast engineering spend across a 12-month engagement.

Arc.dev freelance markup: what you don't know before signing

Arc.dev's exact markup percentage on freelance engagements is not publicly disclosed, and all-in costs are finalized only after final interviews. According to reports, Arc.dev freelance rates run $60-$150/hour, with Arc's platform fee included in the client-facing rate on top of what the developer earns. For full-time placements, the fee structure is clearer: a 20% placement fee based on the developer's annual salary, paid upfront. A developer earning $80,000 annually means a $16,000 placement fee before their first day.

Services covered by Arc.dev fee

Arc.dev's platform fee covers developer sourcing, vetting, and matching. The scope of ongoing operational support may vary by engagement type. Once a freelance developer is placed, the platform's role in day-to-day operations typically diminishes, and you may carry the operational overhead of managing performance, equipment, and compliance directly. This is a relevant comparison point when evaluating staff augmentation versus in-house hiring: a platform markup with limited downstream support often costs more in management time than the rate difference suggests.

The true cost of Arc.dev exit friction

According to Indeed salary data, the average senior software engineer in the US earns about $156,540 per year in base salary. When loaded with benefits, payroll taxes, equipment, and overhead, fully-loaded annual costs reach $195,000 or more. Even if your Arc.dev developer costs less per hour, the switching cost of replacing them approaches local market replacement costs when you factor in transition time. Exit friction on Arc.dev isn't primarily a financial penalty. It's the operational cost of restarting: re-briefing a sourcing process, onboarding a replacement developer to your codebase, and absorbing the institutional knowledge the previous developer accumulated.

Can you afford Arc.dev's switching costs?

Every developer who leaves takes institutional knowledge with them: your codebase architecture, the reasoning behind past technical decisions, and the workarounds that exist because of specific constraints. When a freelance developer exits, the documentation and transition burden often falls on your team. Our 90-day developer onboarding playbook details what a structured transition process looks like when it's built into the engagement model from the start.

IP & code ownership exit terms

IP and code ownership: Arc.dev's Terms of Service contains IP-related provisions covering Talent Content and work products, but the complete scope of IP ownership and transfer terms is governed by supplementary agreement documents not publicly available before signing.

For a CTO, IP ambiguity at exit is a serious risk. The specific questions you need answered in writing before signing are: when does IP created during the engagement formally transfer to you, what happens to code written during a trial period if you exit, and whether any pre-existing IP carve-outs apply to the developer's contributions.

Developer non-solicitation clauses

Non-solicitation: Arc.dev's platform terms contain a non-solicitation provision restricting clients from directly hiring developers discovered through the platform for a defined period after the engagement ends. The exact scope, duration, and any buyout terms are not confirmed in publicly available materials; request the full clause in writing from Arc.dev before signing.

In practice, a developer you worked with through Arc.dev may be off-limits for direct hire for a defined period after your last engagement ends. The cost to hire that developer directly before the non-solicitation period expires is not publicly documented, leaving it as a negotiation point you're unlikely to know before you've already built a working relationship with a specific developer.

Budgeting for replacement engineers

Replacement budgeting: If a freelance engagement ends, your realistic replacement options are: source a new developer through the same or a different platform, or hire locally. Local hiring for a senior software engineer averages 41 days median time-to-hire according to industry benchmarks, and the fully-loaded annual cost runs $150,000-$200,000. The replacement cost isn't just the new developer's rate. It's 41 days of roadmap delay, onboarding ramp time before a new developer is fully productive, and the management time your team invests in the transition.

Cloud Employee exit terms: Minimizing lock-in risk

The following section documents our contract structure at each stage of an engagement: the initial trial period, the minimum commitment window, and the ongoing rolling terms that apply after. Where Arc.dev's full exit terms are distributed across supplementary agreements not available before signing, the terms below are the complete picture.

2-week money-back guarantee

We offer a 2-week money-back guarantee at the start of every engagement. This limits your downside to roughly one month of fees if the developer-client fit isn't right, while giving you enough time to run a real technical evaluation through actual code reviews and sprint participation. The guarantee is backed by a replacement policy, not just a refund: if the initial match doesn't work, we source a replacement developer at no extra cost. The 2-week window covers fit and satisfaction but doesn't pause your broader commitment while you evaluate, so factor this into your decision timeline.

Notice period: Arc.dev vs. Cloud Employee

The comparison table below captures the key contract terms side by side.

‍

Our initial 3-month commitment requires careful consideration: if your runway is under 9 months, committing to a 3-month minimum requires a burn rate calculation. If you need to exit during the initial 3-month period, discuss terms with your Client Success Manager. After that initial period, contracts run on 1-month rolling notice with no cancellation penalties, no conversion fees, and no minimum team size requirements. You can use the price comparison calculator to model your all-in monthly cost before committing.

Comparing platform costs & transparency

We charge $35-$80 per hour depending on developer seniority and geographic source (Philippines, Latin America, or Europe). The monthly fee covers salary, payroll, benefits, HR, a dedicated UK-based Client Success Manager, and a £1,000 per developer L&D budget with personalised development roadmaps and 2 paid work days per year for L&D initiatives. We don't add hidden markups, placement fees, or costs that surface only after final interviews.

That said, offshore developers work best when your bottleneck is engineering capacity, not product-market fit or go-to-market execution. And coordination overhead exists across any distributed team regardless of timezone overlap or tooling integration.

According to a comparison reviewed by Jobbers.io, Arc.dev's charges are only finalized post-final interviews, making pre-commitment budget modeling difficult. For a CTO tracking burn rate weekly, knowing your all-in monthly engineering cost before signing matters more than a headline rate that changes after you've invested three weeks in the interview process. Our full Arc.dev total cost of ownership analysis breaks down the financial picture including screening time and context-switching costs.

Expediting developer replacements

We manage the replacement process through UK-based Client Success Managers rather than self-service platform workflows. When a developer isn't meeting expectations, your Client Success Manager opens a replacement process immediately: requirements are re-briefed, and we present CTO-vetted candidates within 7 working days. Onboarding a replacement still requires codebase knowledge transfer and sprint integration time, so factor transition overhead into your timeline even with fast candidate delivery.

Our 97% developer retention rate over 2+ years means most clients don't encounter the replacement scenario at all. The compounding value of a developer who stays 3+ years and accumulates full codebase context is a direct financial advantage, and the infrastructure driving that retention includes £1,000 annual L&D budgets per developer, dedicated Talent Success Managers, and structured 90-day onboarding with weekly performance scorecards.

This is what that infrastructure looks like in practice. One developer noted:

"The Learning & Development opportunities are outstanding, providing a wealth of resources for professional growth... It's refreshing to work for a company that prioritizes its employees' well-being." - Verified user review of Cloud Employee

Salmon Software's CTO, Marcus Kilgour, captured the vetting side of that equation: "What I love about Cloud Employee is that you've taken all of that hard work off my shoulders. When I was presented with a shortlist of candidates, I knew they were all technically proficient. I knew that they would fit in as part of the team." See the full Salmon Software case study for context on how that team scaled to 11 engineers in 6 weeks.

Future-proofing your platform commitments

Before signing any Arc.dev agreement, get written answers to these three questions:

1. IP ownership clause: "Can you provide the exact IP ownership clause from your standard Freelancer Sourcing Agreement? Specifically: when does IP transfer to us, what happens to code created during the trial period if we terminate, and are there any pre-existing IP carve-outs from the developer's prior work?"
2. Non-solicitation buyout cost: "What is the exact formula or dollar amount to hire a specific developer directly after our engagement ends? Is this a percentage of annual salary, a flat fee, or negotiable? Does the 12-month non-solicitation period still apply if we pay your conversion fee?"
3. All-in hourly cost in writing: "Your website lists developer rates at $60-80/hour. What is your platform fee in dollars, and what is my total all-in cost per hour, documented before I commit to any interviews?"

Arc.dev exit & cancellation terms

When reviewing any developer platform's exit terms, the practical items worth examining are: the notice period to exit, the cost to hire a developer directly, the IP ownership transfer process, and what knowledge transition support exists. Arc.dev publishes some of these clearly and leaves others less visible until after you've committed to the process. The risk isn't that Arc.dev's terms are necessarily unfavorable. It's that you may not be able to model your exit cost before you're in the engagement.

Identifying vendor lock-in signs

Three red flags to watch across any offshore developer platform contract:

• Undefined trial period duration: "Risk-free" terms that don't specify an exact number of days give the platform discretion to limit your replacement options.
• Post-interview pricing finalization: Any platform that won't disclose all-in rates until after final interviews has an information asymmetry advantage during negotiation.
• Non-solicitation without a published buyout rate: A non-solicitation restriction with no transparent conversion fee creates an exit cost you can't calculate until you need to.

The Arc.dev alternatives guide for 2026 covers how different platform models compare on contract flexibility, including how our rolling terms compare to Andela's 12-month minimums and Toptal's hourly engagement model. If you're evaluating common pitfalls before signing any staff augmentation agreement, the staff augmentation mistakes guide covers the operational failures that cost the most.

Calculate your engineering cost savings with our price comparison calculator, then contact us to review transparent contract terms and get CTO-vetted candidates within 7 working days.

Key terms glossary

Fully-loaded cost: The total annual expense of employing a developer, including base salary, payroll taxes, benefits, equipment, management overhead, and any platform or recruitment fees. For a senior developer in the US, this figure typically runs $150,000-$200,000 annually.

Non-solicitation clause: A contractual restriction preventing one party from directly recruiting or hiring individuals connected to the other party. In developer platform contracts, this typically prevents clients from hiring a developer directly for a defined period (commonly 12 months) after the engagement ends.

Employer of record: A third-party organization that legally employs workers on behalf of a client company, handling payroll, benefits, tax compliance, and HR administration while the client manages the developer's day-to-day work. We operate as employer of record for developers placed with client teams.

Notice period: The minimum time a party must give before terminating a contract. On Arc.dev, a notice period applies to platform account termination; verify the current duration directly with Arc.dev before signing. Our notice period after the initial 3-month commitment is 1 calendar month.

Conversion fee: A fee charged by a staffing platform when a client wishes to hire a developer directly rather than through the platform's ongoing commercial relationship. We charge zero conversion fees. Arc.dev's conversion fee for non-solicitation buyout is not publicly documented.