Non-technical founders usually meet this question with a budget and a deadline. One developer on Upwork quotes a number, an agency quotes three times that with a nicer deck, and someone in a founders' group says what you really need is a CTO. All three can be right. They answer different questions.
A freelancer and an agency sell capacity: hours of engineering. A fractional CTO sells judgement: which technical decisions to make, in what order, and whether the people doing the work are doing it well. Choosing between them gets easier once you separate those two needs.
The comparison table
The short answer: freelancers are the fastest and cheapest way to get a defined piece built, agencies give you a team and a process, and a fractional CTO gives you ownership of the technical decisions without a full-time hire. Here is how they compare on the things that matter after launch.
| Freelancer | Dev agency | Fractional CTO | |
|---|---|---|---|
| Who makes technical decisions | The freelancer, often implicitly | The agency's lead, optimised for their delivery | The fractional CTO, on your behalf, written down |
| Accountability | To the task you described | To the contract and the statement of work | To your company's outcomes (uptime, cost, hiring, roadmap) |
| Continuity | Low: one person, may take another client | Medium: the team rotates, but the company remains | High for decisions and knowledge, not a source of daily coding hours |
| IP and code ownership | Only what the contract assigns in writing | Only what the contract assigns; watch for reused "frameworks" | Usually no code to own; decisions and documents should be yours |
| Cost model | Hourly or fixed price per task | Fixed-price projects or monthly team retainers | Monthly retainer for a slice of a senior person's time |
| Speed to start | Days | Weeks (scoping, contracts, staffing) | Days to weeks |
| Quality control | Whatever the freelancer applies to their own work | The agency's internal review, if it exists | Independent review of whoever builds |
| Best at | Well-defined, bounded work | Building a whole product or feature set end to end | Strategy, architecture, hiring, vendor oversight, due diligence |
The row founders overlook most is the first one. Someone is making architecture decisions on every project. With a freelancer or an agency, the person making them is also the person being paid to deliver quickly, and their incentives are not quite yours.
Freelancer: when it fits
A freelancer fits when the work is bounded and you, or someone you trust, can judge the result. A landing page, an integration with a specific API, a prototype to test with ten customers, extra hands for a team that already has a lead.
It goes wrong when a single freelancer becomes the whole technical team by accident. The prototype becomes the product, the freelancer becomes the only person who understands it, and a year later you find out the production database is in their AWS account. In our experience that pattern is the most common technical problem we see at seed stage, and it's the first thing a reviewer will flag in technical due diligence.
Dev agency: when it fits
An agency fits when you need a product built end to end and don't yet have the team to do it. You get designers, developers and a project manager at once, and a company that will still exist if one engineer leaves.
The trade-offs are cost per hour, less flexibility once a fixed scope is signed, and a natural pull toward the agency's preferred stack, which may not be the one you can hire for later. Agencies are also paid to deliver what's in the statement of work, so the quality of that document decides the quality of the outcome. Most founders write it without technical help.
Fractional CTO: when it fits
A fractional CTO fits when the main risk is making the wrong technical decisions, not a shortage of hands. That's usually true when the founders are non-technical, when an outside team builds the product, when an investor or enterprise customer starts asking technical questions, or when it's time to hire the first engineers.
A fractional CTO usually won't write your features every day. If you need both judgement and capacity, you combine them, which is where this gets interesting. Our post on fractional vs full-time CTOs covers when to move from fractional to a full-time hire.
Which one at which stage
The right mix changes as the company grows. This is how we'd think about it, assuming a non-technical founding team.
| Stage | Usually works | Watch out for |
|---|---|---|
| Idea, testing demand | A freelancer or no-code, kept deliberately throwaway | Treating the prototype as the product |
| Building the first real version | Agency or 2 to 3 freelancers, with a fractional CTO setting architecture and reviewing | Fixed-scope contracts written without technical input |
| Live product, first revenue | Fractional CTO plus first in-house engineers; agency for peaks | Agency knowledge leaving with the agency |
| Raising a round, enterprise customers | Fractional CTO owning due diligence, security and the roadmap | Missing IP assignments, personal accounts |
| Team of 6 to 10 engineers | A full-time engineering lead or CTO, often hired with the fractional CTO's help | Keeping a fractional arrangement past the point it fits |
How to combine them
The setup that works best for most early companies is a fractional CTO overseeing an agency or a small group of freelancers. The builders provide capacity; the CTO provides direction and independent quality control.
In practice that means the fractional CTO:
- Writes or reviews the statement of work, so it describes outcomes and quality standards, not just screens.
- Makes the architecture decisions the builders work within: cloud, data model, hosting, third-party services.
- Sets up the company-owned accounts (code hosting, cloud, CI) that everyone works in. See AWS Organizations from day one for the cloud side.
- Reviews pull requests for the critical parts, or at least samples them, and reads the CI results.
- Joins sprint reviews and translates progress into plain language for the founders.
- Plans the handover from external builders to the first in-house hires, and helps run those hires. Our guide to hiring senior engineers in Greece covers that market.
The one rule: the person who reviews the work should not be paid by the people doing the work. An agency's own "CTO" is a useful role, but it isn't independent oversight.
You can enforce review mechanically. A CODEOWNERS file plus a branch protection rule that requires code-owner review means no change to the critical paths merges without your technical lead seeing it.
# .github/CODEOWNERS in your company's repository
# Default reviewers for everything
* @your-org/builders
# Critical paths need the fractional CTO's team as well
/infra/ @your-org/tech-leads
/src/payments/ @your-org/tech-leads
/src/auth/ @your-org/tech-leads
/.github/ @your-org/tech-leads
Code owners only block a merge when the branch protection rule (or ruleset) for the main branch has "Require review from Code Owners" turned on. GitHub's documentation covers the details, including that the file must be on the base branch of the pull request.
Warning signs, whoever you hire
- The code isn't in your account. "We'll transfer the repo at the end" means you don't have it now.
- Production runs in their cloud account or on their credit card, with no plan to move it.
- No staging environment, no automated deploys. Every release is a manual event only they can perform.
- Every question gets "it's complicated". Good engineers can explain trade-offs in plain language.
- Estimates that never change. Real projects learn things. A plan that never moves usually isn't being tracked.
- A proprietary framework or "platform" under your product that you only get a licence to, not ownership of.
- Resistance to outside review. Confident teams welcome a second pair of eyes.
Contract tips: IP, repositories and access
Put ownership and access in the contract before work starts. Fixing it afterwards depends on goodwill you may no longer have.
IP assignment in writing. Across the EU, the Software Directive (Article 2(3)) gives employers the economic rights in software written by employees in the course of their duties. That rule covers employees, not contractors. In Greece, Law 2121/1993 requires transfers of economic rights to be in writing (Article 14), so a freelancer or agency without a signed assignment can still own your code. Ask for an assignment of all economic rights in the deliverables, effective on creation or on payment, and have a lawyer draft it.
Code in your repositories from day one. Create the GitHub or GitLab organisation under a company email, invite the builders as members or outside collaborators, and require all work to happen there. Same for the cloud account, the domain, the app store listings and every SaaS tool.
Access you can revoke. Personal accounts with MFA for every builder, no shared logins, and CI that deploys with short-lived credentials (for AWS, GitHub Actions with OIDC) rather than long-lived keys. On the last day of the contract you should be able to remove access in an hour.
Third-party and open-source components. Require a list of the open-source licences used and a warranty that no copyleft code was added without your approval. Exclude or license any pre-existing agency code explicitly.
Handover as a deliverable. Documentation, architecture diagram, runbooks, and a set number of hours of knowledge transfer, priced into the contract rather than negotiated at the end.
The short version
Hire a freelancer for bounded work you can judge. Hire an agency when you need a whole team for a while. Bring in a fractional CTO when the decisions matter more than the hours, and use them to make sure whoever builds the product builds it in a way your company owns and can run.
If you're about to sign with an agency or a set of freelancers and nobody on your side can review the plan, a fractional CTO can write the brief, choose the builders and oversee the work. If you'd rather have one partner do both, our software development team builds the product with the same senior oversight built in.
Frequently asked questions
Should I hire a fractional CTO or a dev agency?
They solve different problems. An agency gives you engineering capacity to build the product. A fractional CTO gives you senior judgement: architecture, vendor choice, quality review and hiring. Non-technical founders often get the best result from both, with the fractional CTO writing the brief and independently reviewing the agency's work.
Is it better to hire a freelancer or a development agency?
A freelancer is faster and cheaper for bounded, well-defined work you can judge yourself. An agency suits building a whole product when you need several roles at once and continuity if one person leaves. The risk with freelancers is accidental dependency on one person; with agencies, it is a statement of work written without technical input.
Who owns the code a freelancer or agency writes for my startup?
Only what the contract assigns. EU rules give employers the rights in software written by employees, but not by contractors. In Greece, Law 2121/1993 requires transfers of economic rights to be in writing, so get a signed IP assignment covering all deliverables before work starts, and keep the code in your own repositories.
Can a fractional CTO manage an outsourced development team?
Yes, and it is one of the most common setups. The fractional CTO sets the architecture, writes or reviews the statement of work, owns the company accounts, reviews critical pull requests and reports progress to the founders. The key is independence: the reviewer should not be paid by the team being reviewed.