# Hire a quant developer: roles, test tasks, ownership

URL: https://fincodelabs.com/en/blog/hire-quant-developer · Publisher: Fincode (Fincode Yazılım ve Teknoloji A.Ş.), Istanbul, Turkey · Category: Trading bots · Published: 2026-11-06 · Updated: 2026-11-06

How to hire a quant developer: which role you need, what to specify, a paid test task with hidden checks, who owns the code, and the red flags.

**Short answer:** To **hire a quant developer**, first decide which role you need: a quant researcher tests trading ideas, a quant developer turns written rules or models into production code, and a trading software engineer builds the systems around them. Then put inputs, outputs and failure behavior in writing, pay for a short test task graded by checks the candidate does not see, and get a signed document that transfers the code to you. No developer can promise trading results, and automated trading can lose money.

A profile or an interview rarely shows whether someone's code survives a resent fill, a quantity written as 1e-400 or a restart, and neither settles who owns the code afterwards.

Disclosure: Fincode sells this kind of work, so this guide is not neutral on that point. Fincode builds software from rules the customer wrote and does not supply strategies. The guide states no rates or salaries, the legal texts were read on official sites on 6 November 2026, and none of it is legal advice.

## Quant researcher, quant developer or trading software engineer?

Decide which output you are buying before you search, because the three titles overlap.

**Three roles, by what you receive (titles vary between firms)**

| Role | What you receive | What to test | What not to expect |
| --- | --- | --- | --- |
| Quant researcher | Research notes and a reproducible backtest, with its data, cost and timing assumptions stated | Whether they find a planted bias and report costs and out-of-sample results unprompted | A strategy sure to work: research is a tested hypothesis |
| Quant developer | Production code that implements written rules or a model, with tests | Precision with numbers, time and order states, and tests that cover failures | Decisions about what to trade |
| Trading software engineer | Order gateway, data pipelines, monitoring and deployment | Restarts, reconnection, rate limits and logs | Research or strategy input |

If your rules are written, you need a developer, not a researcher, and a general Python developer for hire can do the work if the test task checks the trading-specific skills. Wanting someone to devise strategies for your account raises the legal question covered further down.

## What to specify before you hire a quant developer

Write a specification that a stranger could build and test without asking you, because quotes, the test task and acceptance all depend on it.

- **Rules or model.** Your own, in writing, with every condition, timeframe and the moment it is evaluated. How to write rules a coder can build is in [trading system development](https://fincodelabs.com/en/blog/trading-system-development), and Fincode publishes a blank [rule document template](https://fincodelabs.com/en/samples/rule-document-template) with no example values.
- **Data.** Source, time zone, what a timestamp marks (bar open or close), how gaps are handled, and the license. Free exchange archives can carry non-commercial terms, as [crypto tick data](https://fincodelabs.com/en/blog/crypto-tick-data) shows.
- **Venue and account.** Exchange or broker, account type, API version and whether a test environment exists.
- **Numbers.** Tick size, lot size, fees, rounding, and whether quantities arrive as text.
- **Failure behavior.** Restart with an open position, partial fills, resent or duplicate messages, stale data.
- **Deliverables.** Repository with history, tests, a runbook, and a list of dependencies with their licenses.
- **Where it runs.** Your cloud account and your keys, with read and trade permission only.

Sign a confidentiality agreement before you share the rule document. Until then, everything a candidate needs, the test task included, can use synthetic data.

## A paid quant developer test task with hidden checks

Use a short, paid task on synthetic data, graded by checks the candidate does not see, instead of puzzle interviews or unpaid work on your real rules.

> **Task sheet for a developer, the same for every candidate.** Write a function that takes fill records, each with an id, a side (BUY or SELL) and a quantity as text, and returns the net position. Quantities move in steps of 0.001 up to 1,000. Raise ValueError for anything invalid.

The grading cases stay private. This script ran on Python 3.11.3 on 6 November 2026 with no network or keys; `naive` is a typical quick first submission.

```python
import re
from decimal import Decimal

STEP, MAX_QTY = Decimal("0.001"), Decimal("1000")     # from the task sheet

def naive(fills):
    seen, pos = set(), 0.0
    for f in fills:
        if f["id"] in seen:
            continue
        seen.add(f["id"])
        pos += float(f["qty"]) * (1 if f["side"] == "BUY" else -1)
    return pos

def parse_qty(raw):                    # plain decimal text only
    if isinstance(raw, str) and re.fullmatch(r"[0-9]+(\.[0-9]+)?", raw):
        q = Decimal(raw)
        if 0 < q <= MAX_QTY and q == q.quantize(STEP):
            return q
    raise ValueError(f"bad qty {repr(raw)}")

def reference(fills):
    if not isinstance(fills, (list, tuple)):
        raise ValueError("bad fills")
    seen, pos = {}, Decimal(0)
    for f in fills:
        if not isinstance(f, dict):
            raise ValueError(f"bad fill {repr(f)}")
        fid, side, qty = f.get("id"), f.get("side"), parse_qty(f.get("qty"))
        if not isinstance(fid, str) or not fid.strip() or side not in ("BUY", "SELL"):
            raise ValueError(f"bad fill {repr(f)}")
        if fid in seen:
            if seen[fid] == (side, qty):
                continue               # a resent copy, already counted
            raise ValueError(f"conflicting fill {fid}")
        seen[fid] = (side, qty)
        pos += qty if side == "BUY" else -qty
    return pos

def F(i, s, q):
    return {"id": i, "side": s, "qty": q}

CASES = [
    ("resent fill counted once", [F("a", "BUY", "1"), F("a", "BUY", "1")], Decimal(1)),
    ("same id, different fill", [F("a", "BUY", "1"), F("a", "BUY", "2")], ValueError),
    ("two fills with empty id", [F("", "BUY", "1"), F("", "BUY", "1")], ValueError),
    ("lowercase side", [F("a", "buy", "1")], ValueError),
    ("flat after 0.1 + 0.2 - 0.3",
     [F("a", "BUY", "0.1"), F("b", "BUY", "0.2"), F("c", "SELL", "0.3")], Decimal(0)),
    ("qty 1e400", [F("a", "BUY", "1e400")], ValueError),
    ("qty 1e-400", [F("a", "BUY", "1e-400")], ValueError),
    ("qty nan", [F("a", "BUY", "nan")], ValueError),
]

def grade(fn):
    passed = 0
    for name, fills, want in CASES:
        try:
            got = fn(fills)
            ok = want is not ValueError and got == want
        except ValueError:
            got, ok = "ValueError", want is ValueError
        except Exception as e:         # any other crash fails
            got, ok = type(e).__name__, False
        passed += ok
        if not ok:
            print(f"FAIL {name}: {got}")
    print(f"{fn.__name__}: {passed}/{len(CASES)} passed")

grade(naive)
grade(reference)
```

Output:

```
FAIL same id, different fill: 1.0
FAIL two fills with empty id: 1.0
FAIL lowercase side: -1.0
FAIL flat after 0.1 + 0.2 - 0.3: 5.551115123125783e-17
FAIL qty 1e400: inf
FAIL qty 1e-400: 0.0
FAIL qty nan: nan
naive: 1/8 passed
reference: 8/8 passed
```

The naive version passed only the plain resend: floats turned 1e400 into infinity and 1e-400 into zero, empty ids counted as duplicates, a conflicting resend vanished, a lowercase buy became a sale, and 0.1 + 0.2 - 0.3 missed zero. Decimal has its own trap: under Python's default settings, q % STEP rounds the remainder of 1e-999999999 to zero, which let an earlier draft of this reference accept it; comparing q with q.quantize(STEP) does not. Ask for the candidate's own tests too, because what they chose to test is evidence in itself.

For other roles, change the task, not the method: give a researcher a synthetic price series with a planted look-ahead error and ask for a written note (see [backtesting pitfalls](https://fincodelabs.com/en/blog/backtesting-trading-strategy-pitfalls)), and give a trading software engineer a restart with a working order and a partial fill, as in [how to test trading bots](https://fincodelabs.com/en/blog/how-to-test-trading-bots).

## Who owns the code a quant developer writes?

An employee's code generally belongs to the employer, while a contractor generally keeps the copyright until a signed written document transfers it.

**Default ownership of software, from official texts read 6 November 2026**

| Jurisdiction | Employee | Contractor |
| --- | --- | --- |
| United States | Work within the scope of employment is made for hire (17 U.S.C. 101); the employer is the author and, unless both sign a written agreement saying otherwise, the owner (201(b)) | Made for hire only if the work is in one of nine listed categories, such as a compilation or a test, and both parties sign a written agreement saying so (s.101); computer programs are not named among them. A transfer of ownership must be in writing, signed by the owner or the owner's authorized agent (17 U.S.C. 204(a)) |
| United Kingdom | The employer is first owner of a literary work made in the course of employment, unless agreed otherwise (Copyright, Designs and Patents Act 1988, s.11(2)); a computer program is a literary work (s.3(1)(b)) | The author is first owner (s.11(1)); an assignment is effective only in writing signed by or on behalf of the assignor (s.90(3)) |
| Turkey | Rights in works made by employees while doing their work are exercised by the employer, unless a contract or the nature of the work says otherwise (Law No. 5846, Art. 18); computer programs count as works of science and literature (Art. 2) | Only the author may exercise the economic rights (Art. 18); contracts on them must be in writing and list each right separately (Art. 52) |

The US Copyright Office's Circular 30, revised August 2024, adds that a commissioned work missing any of the conditions is not a work made for hire. In practice:

- Get a signed assignment covering code, tests, documentation, research notebooks and data scripts, at each milestone.
- Ask which earlier libraries the developer keeps, and take a license to use them.
- Keep the repository, cloud account, data contracts and API keys in your name; rotate the keys when the work ends.
- Get the dependency list with licenses: some open-source licenses attach conditions to distribution.

Cross-border contracts need a lawyer in each country; the clause checklist is in [outsource software development compliance](https://fincodelabs.com/en/blog/outsource-software-development-compliance).

## Algo trading consultant or developer: where the legal line sits

Someone who builds rules you wrote is selling software, while someone who chooses trades for you, runs your account or takes a share of profits may be doing regulated work.

The test is who decides. If you choose the assets, timing, sizes and limits, and the code runs on your account with your keys, the developer is a supplier. An algo trading consultant who picks strategies for you, a researcher paid to design trades for your account, or anyone who wants a performance fee or authority to trade your account may need a license where you or they are based; [are trading bots legal](https://fincodelabs.com/en/blog/are-trading-bots-legal) covers the US, UK, EU and other jurisdictions. For readers in Turkey, Article 99/A of Capital Markets Law No. 6362 treats activity by foreign crypto-asset platforms directed at Turkish residents as unauthorized.

## How to compare quotes from quant developers for hire

Compare quotes only against the same specification and the same deliverables, because a headline price says nothing about what it includes.

1. Send every candidate the same specification and ask for effort by work package, with a list of exclusions; the wider quote checklist is in [crypto trading bot developer](https://fincodelabs.com/en/blog/crypto-trading-bot-developer).
2. Price research and building separately: testing ideas is open-ended, so buy it in time-boxed stages that each end with a written note, while a build can be priced against the specification.
3. Prefer fees tied to scope and effort; a fee tied to trading volume or results changes the developer's incentives.

What drives effort is covered in [trading bot cost](https://fincodelabs.com/en/blog/trading-bot-cost). To see how one seller describes its stages and outputs, read Fincode's [how we work](https://fincodelabs.com/en/how-we-work) page and its [sample test report](https://fincodelabs.com/en/samples/test-report), and ask every candidate, Fincode included, about items on this list they leave out.

## Red flags when you hire a quant developer

Walk away when an offer rests on returns, on someone else's property or on control of your money.

**Red flags and why they matter**

| Red flag | Why it matters |
| --- | --- |
| Promised returns, a quoted win rate or profit screenshots | A developer answers for how software behaves, not for markets. The CFTC's customer advisory of 25 January 2024 lists claims of high returns, or of guaranteed ones, as red flags of fraud |
| A backtest with no costs, no out-of-sample period or no stated data source | It cannot be reproduced or checked |
| An offer to bring code, models or data from a former employer | They may not be the candidate's to give, and a dispute over them would reach your own code |
| Requests for withdrawal rights, your exchange login, deposits or a share of profits | The software needs none of them, and pay tied to results raises the legal question above |
| Refusal of a paid test task, a code review or written ownership terms | You lose the evidence you could check before paying for the full build |

The same advisory says "AI technology can't predict the future or sudden market changes," and that applies to any model a candidate offers.

## Frequently asked questions

### How much does it cost to hire a quant developer?

This guide gives no figure, because the price depends on the scope, the tests and the maintenance you need. Compare quotes against one written specification and one deliverables list.

### Should a quant developer sign an NDA?

Yes, before you share your rule document or any real data. Until then, the test task can run on synthetic data.

### Can a quant developer find a profitable strategy for me?

No one can promise a trading result. Designing strategies for someone else's account can also be regulated, depending on where you both are, so a developer's job is to build the rules you wrote.

### Do I need a Python developer specifically?

Not necessarily. Precision with numbers, time and order states matters more than the language; if you hire for another language, port the hidden checks to it.

## Sources

- [US Copyright Office: Circular 30, Works Made for Hire (revised August 2024)](https://www.copyright.gov/circs/circ30.pdf)
- [US Copyright Office: Title 17, Chapter 1, section 101 (definition of work made for hire)](https://www.copyright.gov/title17/92chap1.html)
- [US Copyright Office: Title 17, Chapter 2, sections 201 and 204 (ownership and transfer)](https://www.copyright.gov/title17/92chap2.html)
- [legislation.gov.uk: Copyright, Designs and Patents Act 1988, section 11 (first ownership)](https://www.legislation.gov.uk/ukpga/1988/48/section/11)
- [legislation.gov.uk: Copyright, Designs and Patents Act 1988, section 90 (assignment and licences)](https://www.legislation.gov.uk/ukpga/1988/48/section/90)
- [legislation.gov.uk: Copyright, Designs and Patents Act 1988, section 3 (literary works include computer programs)](https://www.legislation.gov.uk/ukpga/1988/48/section/3)
- [Mevzuat: Law No. 5846 on Intellectual and Artistic Works, Articles 2, 18 and 52 (Turkish)](https://www.mevzuat.gov.tr/mevzuatmetin/1.3.5846.pdf)
- [CFTC Release 8854-24 (25 January 2024): Customer advisory on artificial intelligence scams](https://www.cftc.gov/PressRoom/PressReleases/8854-24)
- [Capital Markets Law No. 6362, consolidated text, Article 99/A (Turkish)](https://www.mevzuat.gov.tr/mevzuatmetin/1.5.6362.pdf)

> This guide is general information about software and markets, not investment, legal or tax advice. Automated trading can lose money, past or backtested performance does not guarantee future results, and the rules that apply depend on your jurisdiction and your exchange's terms. Sources, checks and corrections: see the [editorial policy](https://fincodelabs.com/en/editorial-policy).

---

Published by Fincode (Fincode Yazılım ve Teknoloji A.Ş.), a software company in Istanbul, Turkey: https://fincodelabs.com/en/blog/hire-quant-developer

Cite as: Fincode, "Hire a quant developer: roles, test tasks, ownership", updated November 6, 2026, https://fincodelabs.com/en/blog/hire-quant-developer