Python Task — Implement a Generic Requirement Model in an Existing Codebase

We are looking for one individual Python developer for a small, clearly scoped, fixed-price engineering task in an existing private codebase.

Fixed price: USD 20

This is not a request to build an application from scratch.

This is not a request to redesign the entire data model.

This is one specific implementation task with:

an existing Python codebase,
existing automated tests,
two sanitized structured fixtures,
a precise implementation specification,
clear acceptance criteria,
and a limited list of files that may be modified.

If the first task goes well, we expect to offer additional small fixed-price tasks.

AI-assisted development is explicitly welcome.

You may use Claude Code, Codex, Cursor, OpenCode, GitHub Copilot or comparable tools.

We will not ask you to share your AI prompts, logs or token usage.

We care about the final code, tests, scope discipline and technical explanation.

You remain responsible for understanding and verifying any code generated by an AI tool.

The Problem

An existing Python application processes structured data using deterministic decision logic.

The current model contains several scenario-specific fields.

We need to introduce a small generic requirement representation so that new kinds of requirements do not always require another dedicated top-level field.

There is also an important semantic requirement.

The application must distinguish between:

UNKNOWN
NOT_APPLICABLE
False
0

These values are not equivalent.

For example:

UNKNOWN != False
UNKNOWN != 0
UNKNOWN != NOT_APPLICABLE

If a value is 0, it must mean:

the value has actually been established as zero.

It must not mean:

the value is unknown.

Likewise, NOT_APPLICABLE must not be used simply because information is missing.

Your Task

Implement a small generic Requirement model inside the supplied existing Python codebase.

You will receive the exact contract to implement.

Conceptually, a requirement will need to represent information similar to:

requirement_id
category
applies_to
mandatory
applicability
value / constraint
verification_status

The exact field names, types and allowed values will be defined in the task specification.

You are not being asked to invent the architecture yourself.

You are being asked to correctly implement an already defined small contract.

Important Design Rule

We do not want this:

new scenario
→ add another special field

next scenario
→ add another special field

next scenario
→ add another special field

We want:

small stable model
+
extensible requirements

Do not solve the task by hard-coding the two supplied scenarios.

What We Will Provide

After hiring, you will receive a private, task-specific code snapshot derived from the existing application.

You will not receive the complete product repository.

The task snapshot will contain:

one clean Git baseline commit,
the relevant existing production Python module(s),
existing tests,
a precise implementation specification,
two sanitized JSON fixtures,
acceptance criteria,
a list of files you may modify,
a list of files you may read,
a list of files you must not modify.

Business-specific names and data will be anonymized.

For example, the fixtures may contain names such as:

Organization A
Scenario A
Scenario B
Region A
Requirement X

Knowledge of the underlying business domain is not required.

You will not receive:

production credentials,
server access,
API secrets,
production database access,
customer data.
Fixture Requirement

You will receive two structurally different sanitized fixtures.

Your implementation must support both.

Where specified in the task instructions, you will migrate these fixtures to the new generic requirement representation.

You must not invent missing information simply to satisfy the schema.

If information is unknown, it must remain unknown.

Definition of Done

The task is complete only when all of the following are true:

The supplied generic Requirement contract is implemented in the existing code.
Both supplied sanitized fixtures load successfully through the actual application model code.
All relevant existing tests still pass.
New regression tests demonstrate the semantic distinction between:
UNKNOWN
NOT_APPLICABLE
False
0
UNKNOWN is never silently converted into False, 0 or NOT_APPLICABLE.
The implementation does not add scenario-specific fields merely to make the two supplied fixtures pass.
There is no hard-coding of Scenario A or Scenario B identifiers.
No unrelated refactoring is introduced.
Only explicitly permitted files are modified.
You provide a short implementation report explaining:
what you changed,
why you changed it,
which tests you ran,
and any limitation or issue you found.
Integration Requirement

This is important.

The deliverable must modify the supplied existing application code.

The following do not satisfy the task:

a standalone prototype,
a new unrelated repository,
a notebook,
a demo-only implementation,
a rewrite from scratch,
a separate library that is not integrated with the supplied code.

We need a patch that can be integrated directly back into the existing application.

Scope Discipline

You will receive an explicit list of:

files you may modify,
files you may read,
files you must not modify.

Please do not perform broad refactors.

If you believe the specification requires a change outside the allowed scope, tell us before making that change.

Do not silently expand the task.

Workflow

Before making substantial changes, please send a short 3–5 point implementation plan.

For example:

1. Read the existing model and tests.
2. Add regression tests for UNKNOWN semantics.
3. Implement the Requirement representation.
4. Migrate the supplied fixtures.
5. Run the complete relevant test suite.

During the task, please send one short checkpoint message after either:

adding the main regression tests, or
completing the main model implementation.

If you become blocked, tell us quickly.

Do not spend many hours silently implementing a different solution.

Deliverables

Please provide:

source-code changes,
updated sanitized fixtures,
regression tests,
complete relevant test output,
Git diff or branch,
short implementation report.

No deployment is required.

Budget

Fixed price: USD 20

This is the fixed price for successful completion of the task described above.

If you cannot complete this specific task for USD 20, please do not apply.

We understand that this is a small budget, which is why the initial task is intentionally narrow and well specified.

Successful delivery may lead to additional paid tasks.

Timing

Please apply only if you can:

start shortly after receiving the task package,
work effectively with an unfamiliar existing Python codebase,
communicate quickly if blocked,
deliver within approximately 24 hours.
AI-Assisted Development

AI-assisted development is encouraged.

You may use your own tools, including:

Claude Code,
Codex,
Cursor,
OpenCode,
GitHub Copilot,
or comparable coding assistants.

For this first task, please use your own normal development and AI tooling.

We pay for the verified engineering result, not for token consumption.

Using an LLM is not a substitute for testing and review.

You remain responsible for the code you deliver.

How to Apply

Start your proposal with exactly:

DATA CONTRACT

Then answer the following questions.

1. Why is this specific task a good fit for you?

2. Which AI coding tools do you normally use when working with an existing codebase?

3. How do you verify code generated or modified by an LLM before delivering it?

4. Briefly describe your experience with Python, pytest or similar automated testing, JSON/data models and Git.

5. Please answer this technical question in your own words:

If a requirement is UNKNOWN, why can replacing it with False or 0 cause incorrect behavior in a data/rules system?

Please provide one concrete example.

6. Describe one situation where you worked with an existing unfamiliar codebase. How did you understand it before making changes?

7. How quickly can you start after receiving the code snapshot and specification?

8. Confirm that you accept the USD 20 fixed price.

Do not send us a completed implementation before being hired.

This is a paid engineering task, not an unpaid coding test.

Please do not send a generic agency introduction.

We are currently looking for an individual freelancer, not an agency.

Successful cooperation may lead to additional small, clearly specified fixed-price tasks.