Python Backend Engineer — FastAPI Hardening + Deterministic Ranking + WebSockets + AI Reviews

Budget: 2400 USD Deadline: 30 days

BENCHMARK

I’ve reviewed the attached Technical Hiring Brief and understand this is production hardening of an existing FastAPI-based vehicle analytics system — not greenfield development.

Below is my structured estimate.

1) Estimated Total Hours

Initial estimate: 160–190 hours
(Subject to ±15% after initial repository audit)

2) Breakdown by Workstream
Backend Stabilization & Hardening

20–25h
• Remove crash paths & unsafe DB access
• Enforce deterministic behavior
• Add structured logging
• Fix SQL predicate bugs
• Add constraints & indexes

WebSocket System (Auth + Multi-instance + Redis)

30–35h
• Replace in-memory socket maps
• Implement Redis async pub/sub
• Authenticated handshake validation
• Deterministic broadcast iteration
• Multi-instance safety
• Async test coverage

Deterministic Pricing Engine

25–30h
• Tiered comparable selection
• Deterministic widening fallback
• Outlier filtering
• Strict Decimal rounding
• Persist benchmark metadata
• Backfill script
• Full formula tests

Deterministic Similar Listings Engine

20–25h
• Weighted scoring model
• Configurable weights
• Hard filters + widening fallback
• Deterministic tie-breaking
• Indexed query optimization

Smart Review (AI + Cache Layer)

25–30h
• Vehicle fingerprint generation
• Web evidence retrieval
• LLM synthesis (evidence-only constraint)
• Redis + DB cache layer
• Versioning + TTL invalidation
• Unique DB index
• Optional force refresh

Notification Lifecycle Completion

10–15h
• Ownership enforcement
• Fix update predicates
• Remove orphaned records
• Transactional consistency
• Endpoint test coverage

Catalog Search Replacement

10–15h
• Real filter-based search
• Validated pagination
• Structured logging
• Integration tests

Facebook Integration

10–15h
• Integrate module
• Resolve schema alignment
• Proxy/account stabilization

Testing + CI Hardening

20–25h
• pytest + pytest-asyncio
• Deterministic snapshot tests
• WebSocket async tests
• Critical flow coverage
• CI compatibility

3) Risks / Unknowns

• Hidden coupling between ranking & pricing logic
• Inconsistent historical data affecting determinism
• WebSocket lifecycle assumptions in current code
• LLM cost management + evidence reliability
• Partial DB migrations

4) Proposed Milestones

Codebase audit + architecture proposal

WebSocket stabilization

Deterministic pricing engine

Deterministic similarity engine

AI smart review + cache layer

DB hardening + backfills

Notification + catalog completion

Test coverag Expand

Budget: 36 USD Deadline: 1 day

BENCHMARK
Hello. I have been working with FastAPI/Node.js/React.I'm ready to cooperate.

Budget: 300 USD Deadline: 30 days

BENCHMARK
Transitioning a "stubbed" vehicle analytics platform to a production-hardened state requires a shift from functional code to reliable infrastructure. My approach focuses on eliminating non-determinism in the scoring engines and ensuring the WebSocket layer scales horizontally via Redis.

### Technical Implementation Strategy

1. **Scaling WebSockets:** To make WebSockets multi-instance safe, I will implement a **Redis Pub/Sub** backend. This ensures that a notification intended for a specific user reaches them regardless of which server instance their client is connected to. Authentication will be handled during the initial handshake via a dependency-injected FastAPI middleware.
2. **Achieving Determinism:** * **Pricing Engine:** I will replace floating-point math with `Decimal` for currency and implement a strict weighting matrix.
* **Similarity Ranking:** I will implement explicit tie-breaking rules (e.g., secondary sort by UUID or creation timestamp) to ensure the same input always yields the same ranked list. Fallback "widening" logic will be moved from random selection to a hierarchical filter expansion (e.g., expanding radius or model year range).

3. **AI Smart Review:** The endpoint will be built with a **three-layer caching strategy**:
* Hash of the input query + prompt version as the Redis key.
* Versioning for prompts to ensure evidence-backed results remain consistent even if the model is updated.
* Asynchronous fetching of web evidence with a "circuit breaker" fallback to local data if external APIs exceed latency thresholds. Expand

Budget: 3000 USD Deadline: 30 days

Hello! 👋
BENCHMARK: I have reviewed the attached technical description of the hiring and am ready to optimize your vehicle analytics platform on Python with FastAPI, SQLAlchemy, Redis (async), WebSockets, relational DB, LLM integration, and Pytest.
I propose to take on the task as an experienced backend engineer, focusing on stabilization, determinism, and testing. I have experience optimizing similar systems (data analytics, real-time notifications, AI integrations).
Workstream distribution:
WebSockets: 25–35 hours (authorization, multi-server security with Redis Pub/Sub, delivery for users)
Pricing: 20–25 hours (deterministic benchmark + data filling, replacing placeholders)
Similarity: 20–30 hours (weighted evaluation, equality solving, reservation, determinism)
AI review: 20–25 hours (endpoint with web proofs, caching/versioning, secure backups)
DB: 15–20 hours (SQL fixes, adding constraints/indexes, query optimization, migrations)
Tests: 20–25 hours (pytest + async coverage, CI readiness)

Risks/unknown factors: Dependence on the current state of the code (possible hidden bugs in incomplete parts); integration with LLM API (if there are limits on requests/models); Redis scalability for WebSockets under high load; DB migrations without downtime; potential changes in requirements after the audit.
Proposed phase plan:
Phase 1 (1–2 weeks): Code audit, environment setup, DB fixes (constraints/indexes, SQL errors).
Phase 2 (2–3 weeks): Stabilization of WebSockets + deterministic pricing/similarity.
Phase 3 (2–3 weeks): AI review endpoint + full testing (pytest/async, CI integration).
Phase 4 (1 week): Final testing, documentation, deployment.

Testing strategy: Initial audit with unit tests on key functions; full coverage of critical flows (WebSockets, pricing, AI) with pytest-asyncio; integration tests with mocks (Redis, LLM API); load tests for WebSockets; CI configuration (GitHub Actions or similar) for automatic test runs on PR.
Required access: Access to the repository (GitHub/GitLab); staging environment for testing; DB (with credentials for dev); Redis instance; API keys for LLM; documentation of the current code (if available).

Ready to discuss details, clarify estimates after the audit, and start working. Expand

Budget: 2200 USD Deadline: 35 days

BENCHMARK

I reviewed the Technical Hiring Brief and understand this is a production hardening engagement for an existing FastAPI vehicle analytics platform, not a new build.

1) Estimated total hours
168h total. Expected range after initial validation: 160-180h. Timeline: 28-35 days.

2) Breakdown by module/workstream
- Backend stabilization + DB hardening — 24h
- WebSocket reliability + Redis + async tests — 28h
- Deterministic pricing + backfill — 24h
- Similar listings engine — 22h
- Analytics graph / image signals — 14h
- Smart review + cache/versioning — 22h
- Notifications + catalog search + Facebook alignment — 18h
- Final QA, CI hardening, migration notes, docs — 16h

3) Risks/unknowns
- DB schema/data quality and migration safety
- Redis/WebSocket topology and concurrency
- depth of placeholder/random logic
- AI evidence retrieval reliability
- current CI / async test baseline
- parser/Facebook schema drift

4) Proposed milestone plan
- M0: free pilot / proof of concept
- M1: stabilization foundation
- M2: WebSocket reliability
- M3: deterministic engines
- M4: AI smart review + analytics signals
- M5: notifications, catalog search, Facebook
- M6: final hardening and release readiness

5) Testing strategy
- deterministic unit tests for pricing/similarity
- async integration tests for WebSockets/notifications
- DB integrity, migration, and backfill tests
- API schema contract tests
- CI-ready pytest / pytest-asyncio

6) Required infrastructure access
- repo + staging
- DB + Redis
- CI config
- LLM/API keys
- deployment topology details

To reduce delivery risk upfront, I can begin with a short free pilot / proof of concept, validate the key architecture assumptions, and then return an implementation map and execution plan.

I am open to discussing details in private messages. Expand

Budget: 3000 USD Deadline: 30 days

BENCHMARK

I reviewed the attached technical hiring brief and understand this is a production hardening task — not a greenfield build.

I specialize in stabilizing async Python systems (FastAPI, SQLAlchemy, Redis, WebSockets) and converting placeholder/random logic into deterministic, production-grade implementations.

### Estimated Scope
Total: ~150 hours (milestone-based)

Breakdown (approx):
- WebSockets (auth, per-user delivery, Redis multi-instance safe): 30h
- Deterministic pricing engine + backfill: 25h
- Deterministic similarity engine: 20h
- AI smart review (evidence-based + caching/versioning): 25h
- DB fixes, constraints, indexes, migrations: 20h
- Tests (pytest + async CI-ready coverage): 20h
- Other integrations & cleanup: 10h

### Risks / Unknowns
- Current DB schema/index quality
- Existing randomness embedded in business logic
- Web evidence retrieval constraints
- State of current WebSocket infra

### Milestones
1) DB stabilization + crash path removal
2) Deterministic pricing & similarity engines
3) WebSocket hardening (multi-instance safe)
4) AI review productionization
5) Full test coverage + CI validation

### Testing Strategy
- Strict deterministic unit tests for scoring engines
- Async integration tests (pytest-asyncio)
- WebSocket flow tests
- Backfill validation tests
- Query performance verification

### Required Access
- Full repo
- Staging DB + Redis
- LLM API access
- CI config

I focus on determinism, defensive programming, clean constraints, and CI-ready coverage. Ready to proceed milestone-driven. Expand

Budget: 5000 USD Deadline: 30 days

BENCHMARK — I confirm I reviewed the attached technical hiring brief
Technical Hiring Brief

Introduction
Senior Python backend engineer focused on production hardening, deterministic analytics systems, and async architectures (FastAPI + Redis + WebSockets + LLM pipelines).
Strong experience converting research/beta platforms into stable, CI-ready production services.
Estimated Total Effort
~180–220 hours
Workstream Breakdown

1. WebSockets Reliability — 35–45h
Authenticated sockets
user_id → socket registry
Redis pub/sub (multi-instance safe)
broadcast safety + preference filtering
reconnect + delivery guarantees

2. Deterministic Pricing Engine — 30–40h
Replace placeholder margin logic
Comparable widening fallback
Outlier filtering
Strict rounding policy
Benchmark metadata persistence
Backfill job

3. Similar Listings Engine — 25–35h
Weighted scoring model
Deterministic tie-breaking
Indexed queries
Schema-safe responses

4. AI Smart Review System — 30–40h
Vehicle fingerprinting
Web evidence retrieval
Evidence-only LLM synthesis
Cache + versioning + TTL
Safe fallback handling

5. Database Hardening — 20–25h
Constraints/indexes
SQL bug fixes
Migration notes
Query optimization

6. Testing & CI — 35–45h
pytest + pytest-asyncio
WebSocket tests
deterministic engine tests

integration flows
CI pipeline readiness
Risks / Unknowns
Hidden coupling between pricing & matcher logic
Existing data inconsistencies affecting determinism
WebSocket lifecycle edge cases across deployments
External web evidence reliability for AI reviews
LLM latency/cost constraints

Proposed Milestones
M1 — Stabilization & DB Hardening
Constraints, logging, SQL fixes
M2 — WebSocket Reliability Layer
Redis multi-instance delivery
M3 — Pricing Engine (Deterministic)
Logic replacement + backfill
M4 — Similar Listings Engine
M5 — AI Smart Review Productionization
M6 — Testing + CI Hardening + Final QA

Testing Strategy

Unit tests for pricing/scoring determinism
Async integration tests for WebSockets
DB migration validation tests
Snapshot tests for AI review outputs
CI pipeline enforcing coverage thresholds
Required Access
Repository + branch strategy
Staging environment
DB + Redis access
Existing test infra (if any)
LLM/API credentials
Deployment topology overview

Ready for milestone-based contract and immediate start. Expand

Budget: 1649 USD Deadline: 30 days

BENCHMARK

Reviewed the brief.

We’re StrawBerry Cats — backend-focused team specializing in production hardening and deterministic systems.

We can help you replace placeholder logic, eliminate randomness, stabilize WebSockets using proper event streaming (Redis/Kafka depending on architecture), ship deterministic pricing & similarity engines, implement AI review with caching/versioning, and add real async test coverage + DB integrity.

We work milestone-driven with structured task management — you’ll always see progress and what’s being delivered.

$1500/month per full-time backend engineer.
Need faster delivery? We can scale capacity if tasks aren’t blocked.

Happy to discuss details in private after the bid is accepted.

Note: The stated term in the bid is conditional and serves only as an initial engagement window — the actual timeline depends on scope depth and debugging complexity. Expand

Budget: 25 USD Deadline: 1 day

BENCHMARK I have gone through the hiring brief and the tech stack looks solid, but I noticed a bit of a contradiction in the requirements for the WebSocket system.
The brief mentions maintaining a user_id active sockets mapping and preventing mutation during broadcast iteration, but at the same time, it asks for multi-instance support via Redis. Technically, if we scale to multiple instances, a local Python dictionary (mapping) on one server won't see users connected to another server.
If we're moving to Redis Pub/Sub, we should probably ditch the manual broadcast iteration entirely. Each instance should just subscribe to specific user channels in Redis, which natively handles the distribution and avoids any "mutation during iteration" bugs.
The rest of the tasks kike making the pricing and similarity engines deterministic and hardening the AI review layer are clear. I’m especially interested in replacing those random placeholders with a proper weighted scoring model.

Budget: 25 USD Deadline: 1 day

BENCHMARK
Good evening, Max!
The overall task is clear. To give you a precise answer regarding timeframes and pricing, I'd like to clarify a few questions I had after analyzing your task.
Privately message me—we'll discuss the details and your preferences.

Budget: 6000 USD Deadline: 40 days

BENCHMARK
Hi Max,
I have reviewed the Technical Hiring Brief carefully. The scope is clear: this is production hardening of an already functional system, with emphasis on determinism, multi-instance reliability, data integrity, and replacing mock logic with stable implementations.
I work primarily on FastAPI async backends that require strict determinism, financial correctness, and horizontally scalable real-time layers. This scope aligns well with that experience.
Estimated total effort
Approximately 180 to 220 hours after a short initial audit.
Breakdown by workstream
Backend stabilization and hardening
25 to 35 hours
Null safety, predicate fixes, constraint enforcement, index review, structured logging, deterministic cleanup.
WebSocket reliability and multi-instance support
30 to 40 hours
User to socket mapping isolation, async Redis pubsub or streams, mutation safe broadcast logic, notification preference enforcement, async integration tests and CI compatibility.
Deterministic pricing engine
25 to 35 hours
Tiered comparable selection, widening fallback without randomness, strict rounding policy using Decimal, outlier filtering, benchmark metadata persistence, backfill script, deterministic regression tests.

Deterministic similarity engine
25 to 35 hours
Weighted scoring model, configurable weight schema, hard filters with widening fallback, deterministic tie breaking, indexed query optimization, stable response contract.
Analytics graph and image intelligence integration
15 to 25 hours
Reconnect classifier in DAG, merge signals into matcher decisions, conflict resolution rules, failure fallback, observability logging.
Smart review AI with cache layer
25 to 35 hours
Vehicle fingerprinting, evidence retrieval, LLM synthesis with evidence bound output, Redis caching keyed by fingerprint, unique DB constraint, TTL and version invalidation, forced refresh option, schema validation.
Notification lifecycle completion
15 to 20 hours
Predicate correction, ownership enforcement, orphan cleanup, transactional consistency, uniqueness constraints, endpoint coverage.
Catalog search replacement
10 to 15 hours
Validated filter based search, pagination guarantees, structured logging, integration tests.
Facebook integration alignment
10 to 15 hours
Module integration, proxy and account fixes, schema normalization with other parsers.
Risks and unknowns
Current data consistency level in production database
Hidden nondeterministic behavior in ranking or fallback logic
Edg Expand

Budget: 3000 USD Deadline: 60 days

BENCHMARK

Підтверджую, що переглянув прикріплений Technical Hiring Brief і розумію, що мова йде саме про production hardening існуючої системи, а не про greenfield-розробку.

Я спеціалізуюсь на стабілізації та детермінізації backend-систем на FastAPI/async-стеку, включаючи Redis, WebSockets, AI-інтеграції та оптимізацію SQL. Для мене це типова задача “перевести working prototype у production-grade систему”.

1. Оцінка загальних годин

Орієнтовно: 140–190 годин

(залежить від якості поточного коду, реального стану WebSocket-шару та pricing/similarity логіки)

2. Розподіл по потоках

WebSockets (auth + multi-instance + Redis + tests)

25–35 годин

Deterministic Pricing Engine

20–30 годин

Deterministic Similarity Engine

20–30 годин

Smart Review (LLM + evidence + cache + versioning)

20–30 годин

DB hardening (constraints, indexes, fixes, migrations)

15–25 годин

Notification lifecycle + consistency

10–15 годин

Analytics graph + image signal integration

10–20 годин

Testing (pytest + async + CI-ready)

20–30 годин

3. Ризики / невідомі фактори
• Реальний стан async-коду (race conditions / blocking calls)
• Поточна структура Redis (pub/sub чи ad-hoc логіка)
• Наскільки pricing/similarity вже переплетені з іншими модулями
• Стан DB міграцій та історії schema drift
• Наскільки AI-endpoint зараз mock-ізольований або вже частково інтегрований

4. Пропонований план етапів

Milestone 1 – Stabilization Layer
• Crash-path cleanup
• Structured logging
• DB constraints & index plan
• Deterministic enforcement across APIs

Milestone 2 – WebSocket Reliability Layer
• Authenticated WS
• Redis async pub/sub
• Multi-instance safety
• Async test coverage

Milestone 3 – Deterministic Engines
• Pricing engine rewrite
• Similarity engine rewrite
• Backfill scripts
• Full formula testing

Milestone 4 – AI Smart Review
• Fingerprinting
• Evidence retrieval layer
• LLM synthesis with strict schema
• Cache + versioning + TTL

Milestone 5 – Coverage & CI Hardening
• Pytest + pytest-asyncio
• Integration tests
• CI-ready pipeline

5. Стратегія тестування
• Unit-тести для формул pricing та similarity (детермінованість гарантована)
• Async WebSocket tests з test Redis instance
• DB constraint tests
• AI endpoint contract tests (schema + cache hit/miss)
• Regression tests на edge cases
• CI integration з async runner

6. Необхідний доступ
• Git repository (full history)
• Staging environment
• DB dump або staging DB access Expand

Budget: 1000 USD Deadline: 30 days

BENCHMARK
We can help productionize and harden your existing vehicle analytics platform with a focus on determinism, reliability, and CI-ready test coverage.
Estimated Total Effort - 200 hours total
(Depends on current code quality, DB state, and existing WebSocket architecture.)
Breakdown by Workstream
1) WebSockets (Auth + Redis multi-instance safety)
2) Deterministic Pricing Engine
3) Deterministic Similarity Engine
4) AI Smart Review Endpoint
5) Database Hardening
6) Testing & CI
Risks / Unknowns
- Existing schema integrity issues
- Hidden race conditions in async flows
- Current WebSocket infra limitations
- LLM cost/performance tradeoffs
- Legacy non-deterministic logic embedded deep in services
Proposed Milestones
Milestone 1: WebSocket stabilization + auth + Redis
Milestone 2: Deterministic pricing + similarity engines
Milestone 3: AI review endpoint (with caching/versioning)
Milestone 4: DB hardening + performance
Milestone 5: Full test suite + CI integration
Each milestone delivered with validation checklist.
Testing Strategy
- Deterministic output snapshot tests
- Async integration tests
- Redis-backed WebSocket tests
- AI endpoint response validation + cache verification
- Performance validation for critical queries
Required Access
- Source repositories
- Staging environment
- DB + Redis access
- LLM API keys
- CI configuration (if exists)
If you'd like, I can first perform a short audit phase (10–15 hours) to reduce estimation uncertainty before committing to a fixed milestone budget.
Looking forward to collaborating. Expand

Budget: 350 USD Deadline: 30 days

BENCHMARK — підтверджую, що я переглянув повний прикріплений Technical Hiring Brief і розумію обсяг робіт, архітектуру системи та очікування щодо production-hardening існуючого Python/FastAPI бекенду.
Загальна оцінка часу
Орієнтовно: 220–260 годин
(після 1–2 днів глибокого codebase audit оцінка може бути скоригована ±10–15%)
Мій рейт: 12 USD / година
Формат: контракт, поетапна оплата — підходить.
1. Розподіл годин за модулями
1) Backend Stabilization & Hardening
25–30 год
• Усунення crash-paths, null handling
• Structured logging
• Fix SQL predicate bugs
• Constraints + ownership enforcement
• Повна детермінізація API-виходів
2) WebSocket Notification System (Auth + Reliability + Redis)
40–45 год
• broadcast_to_client
• user_id → active sockets mapping
• Safe iteration during broadcast
• Async Redis (pub/sub або streams)
• Notification preference filtering
• Multi-instance safety
• Async WebSocket tests + CI support
3) Deterministic Pricing Engine (listing_margin)
30–35 год
• Tiered comparable selection
• Deterministic widening fallback
• Outlier filtering
• Strict rounding policy
• Persist benchmark metadata
• Backfill script для існуючих даних
• Unit + integration tests
4) Deterministic Similar Listings Engine
30–35 год
• Weighted scoring model
• Configurable weights
• Hard filters + widening fallback
• Deterministic tie-breaking
• Indexed query optimization
• Stable response schema
5) Analytics Graph Enhancements (Image Intelligence)
20–25 год
• Reconnect image classifier in DAG
• Merge image + text signals
• Conflict resolution logic
• Safe fallback
• Observability logs
6) Smart Review (AI + Cache Layer)
30–35 год
• Vehicle fingerprint generation
• Web evidence retrieval
• LLM synthesis (evidence-only)
• Redis cache + DB uniqueness index
• TTL + version invalidation
• Forced refresh
• Schema-compliant output
7) Notification Lifecycle Completion
15–20 год
• Update predicate fixes
• Ownership enforcement
• Cleanup orphaned notifications
• Transactional consistency
• DB uniqueness constraints
• Endpoint test coverage
8) Replace Placeholder Catalog Search
15–20 год
• Real filter-based search
• Validated pagination
• Structured logging
• Error handling
• Integration tests
9) Facebook Integration
10–15 год
• Integrate existing module
• Resolve account/proxy issues
• Schema alignment with core
There is a limited number of characters in this window, so I cannot give you the full answer I would like to. Expand

Budget: 5000 USD Deadline: 20 days

BENCHMARK
Good day
My name is Dmytro, from King Kong Web

I have reviewed the technical description. I understand that this is not a startup "from scratch," but an enhancement of an already functioning system with a focus on determinism, stability, and production-ready level.

We have experience working with FastAPI, async architecture, Redis, WebSockets, SQLAlchemy, and LLM API integrations. We are ready to proceed step by step and close each direction with a separate milestone.

Preliminary estimate
Total volume: approximately 120–180 hours (we can clarify after the audit).

Estimated distribution
WebSockets (authorization, per-user delivery, multi-instance via Redis) — 25–35 hours
Deterministic pricing + backfill — 20–30 hours
Deterministic similarity engine (weights, tie-breaking, fallback) — 20–30 hours
AI review endpoint (evidence, caching, versioning, fallback) — 20–30 hours
Database optimization (indexes, constraints, migrations, performance tuning) — 15–25 hours
Tests (pytest + pytest-asyncio, critical flows, CI ready) — 20–30 hours

Risks and unknown factors
Current state of architecture and level of technical debt
Quality of existing migrations and data
Load (actual RPS, number of simultaneous WebSocket connections)
Degree of module interconnectivity
Quality of current LLM integration

Stage plan

Technical audit (code, database, WebSocket logic, CI)

Stabilization of WebSockets and Redis pub/sub

Extraction of deterministic pricing and similarity logic

Implementation of AI review endpoint with caching and versioning

Database optimization (indexes, constraints, explain plans)

Full test coverage of critical flows

Final load testing and documentation

Testing strategy
Unit + async unit tests
Integration tests for WebSocket flows
Determinism tests (repeatability of results)
Caching and fallback logic tests
CI with automatic pytest runs

Required accesses
Git repository
Access to staging
Access to database and Redis
LLM API keys
Information about the deployment environment
Access to CI (if configured)

We are ready to start with the technical audit and then finalize the exact hour estimate for each stage. Expand

Budget: 650 USD Deadline: 5 days

Hello! I am interested in your project to strengthen the backend on FastAPI. We have experience working with this framework and understand the specifics of hardening processes and working with WebSockets.
Our advantages:
• Technologies: We are proficient in FastAPI, working with asynchronous programming and connection security.
• Quality: We will conduct an audit of the current code, close vulnerabilities, and optimize WebSocket logic.
• Format: We work in a "Developer + Manager" format. I (the manager) am always available for prompt resolution of issues, while the technician focuses on the code.
We are ready to discuss technical details and start working. Please write in private messages so we can orient you on timelines after clarifying the technical specifications.

Budget: 200 USD Deadline: 3 days

Hello! Your project looks wonderful. I am ready to start working immediately and complete it at a high level.