Tech Lead / Security Auditor (Python/FastAPI) — Architecture Control and Bus-factor

Briefly: I do not need a developer. I need a "Digital Auditor" to oversee the development of a complex infrastructure SaaS platform.

Project stack: Python 3.12+, FastAPI, Redis (as message broker & cache), PostgreSQL (SQLAlchemy/Tortoise), Docker.

Your mission:

You act as the owner's trusted representative. You ensure that the developer builds a reliable system, not a "patchwork" pyramid that will collapse after going into production.

Responsibilities (Strict Control):

1. Zero-Trust Code Review: Every iteration of the developer goes through your audit. Check for Memory Leaks, SQL injections, and the security of Pydantic schemas.

2. Backdoor Hunting: Searching for hidden vulnerabilities, unauthorized logs, or third-party requests.

3. Architecture Validation: Monitoring compliance with SOLID and Clean Architecture. You must prohibit "spaghetti code" at early stages.

4. Disaster Recovery Check: Confirming that the project can be deployed in 5-10 minutes from scratch (Docker) and any other Senior can pick it up tomorrow.

5. Milestone Approval: You are the last barrier before payment. The developer receives money only after your technical report.

Requirements (Senior/Lead only):

• Experience as an architect or tech lead for at least 5 years.

• Deep knowledge of asynchronous programming in Python (Asyncio).

• Understanding of how residential proxies work, HTTP header spoofing, and bypassing anti-fraud systems (will be a critical advantage).

• Ability to convincingly "reject" a developer's poor solution.

Filter questions for response (MANDATORY):

1. How will you check asynchronous code for blocking I/O operations that could "bring down" the system under load?

2. What signs in Dockerfile or docker-compose.yml indicate that the project's architecture is not isolated?

3. What is the Bus-factor in your understanding and how will you minimize it in this project?

Audit object and scope of work:

The project consists of 4 key modules, each requiring a separate stage of technical acceptance:

1. CORE Module (Python/FastAPI): In-depth Code Review of the architecture. Checking for Memory Leaks, Race Conditions in Redis queues, and auditing the security of Pydantic schemas.

2. NETWORK Module (Proxy/Stealth): Analyzing outgoing traffic for Backdoors and leaking the real IP of the server. Checking the logic of HTTP header spoofing.

3. INFRA Module (Docker): Checking Disaster Recovery. Validating that the system can be deployed from scratch in 5-10 minutes without the involvement of the code author.

4. JS Module (Injection): Auditing the quality of obfuscation and protection against debugging (Anti-F12).

Responsibilities involve auditing the 4 modules (Core, Network, Infra, JS) for vulnerabilities and Bus-factor. Each audit concludes with a written report. This is a fixed scope of work.