Improvement of Node.js/TypeScript price pipeline: PostgreSQL, Python, Shadow Mode

Budget: 18000 UAH Deadline: 9 days

Good day, Evgeny!

I will take this as a targeted refinement of the existing pipeline, rather than as a "rewrite alongside." The key point here is to safely integrate the new engine into the staging/shadow contour so that neither the cron, the current production logic, nor the canonical data of the catalog is broken until the end of QA.

What I will do for the mandatory scope:
— integrate the Python module as a separate component with explicit contract validation on the Node.js side;
— replace DELETE→CREATE with a snapshot-safe UPSERT stream: STALE only for a fully successful snapshot, without degradation during a partial/failed run;
— update offers + selected offer metadata + shadow fields in one PostgreSQL transaction with full rollback;
— expand offers without a parallel new system if the current schema can be safely migrated;
— add refresh execution by a single slug/id and list via CLI or the existing service API;
— preserve the current cron/batches/cooldown/PRICE_REFRESH_MIN_DAYS and legacy pipeline until the completion of Shadow QA;
— perform audit output in the lightest and safest manner after reviewing the current admin table.

From experience: I regularly work with PostgreSQL migrations, transactional updates, idempotent ingestion/snapshot pipelines, and integrations between Node.js and separate Python components, where it is critical not to corrupt active data during incomplete runs.

My estimate:
1. Fixed price for the mandatory scope — 29,000 UAH.
2. Promotion mechanism separately — 7,000 UAH.
3. Timeline — 10–12 working days.
4. Estimate — 55–70 hours.
5. Ready to start — within 24 hours after access to the repository and staging.
6. Staging, QA, migrations, and bug-fix period of 7+ days — included.

What needs to be clarified before starting:
— how the Python module is currently called and what the format of the partial/error response is;
— the current schema of offers and where the selected offer / price metadata is currently stored;
— what is used to perform migrations and whether staging deploy is available through the existing process;
— is there already a field/status for STALE or does it need to be introduced into the current model;
— which option for audit output is preferable: admin table or CSV.

If you want, I can provide a short technical review plan in the first message after access: which parts of the code we touch, what migrations we make, and where the most risky rollback points are.

🌐 My portfolio with recent cases:
https://mrnko.com
💼 Freelancehunt profile:
Freelancehunt
🤝 I would be happy to discuss the details, answer your questions, and offer the optimal solution for your project. Expand

Budget: 15000 UAH Deadline: 8 days

It is clear that the task is not about rewriting the backend, but about securely integrating a new price pipeline while preserving the existing production logic. It is necessary to integrate a Python module into Node.js/TypeScript, implement Shadow Mode, replace DELETE→CREATE with UPSERT, add transactional updates for PostgreSQL, STALE logic, trigger refresh by slug/id, and perform migrations, staging, and QA without impacting production.

Before starting, it is worth clarifying a few points: how Node.js currently interacts with Python (CLI, HTTP, or another mechanism), what format of the Python module's response is already implemented, how the current schema of the offers table is structured, and whether ORMs (Prisma, TypeORM, etc.) or pure SQL are used. It is also important to understand how the refresh pipeline and cron currently work so that the integration does not disrupt the existing logic.

I have experience working with Node.js/TypeScript, PostgreSQL, migrations, transactions, REST APIs, and enhancing existing backend projects without complete rewrites. I understand how crucial it is in such tasks to maintain production stability and gradually introduce new logic through staging and Shadow Mode.

I am ready to discuss the architecture details, assess the mandatory scope separately from the promotion mechanism, and after familiarizing myself with the codebase, provide an accurate cost, timeline, and hour estimate.

Budget: 8600 UAH Deadline: 10 days

I regularly work with exactly these tasks — integrating Python modules into a Node.js/TypeScript pipeline, shadow mode for safe rollout, and transactional UPSERT schemes in PostgreSQL. I suggest discussing the details of the contract between Python and Node.js, clarifying the current cron structure, and validating the approach on staging.

Budget: 27000 UAH Deadline: 7 days

Hello! The task is extremely clear and well-structured. Below is a detailed assessment of the enhancement of your price refresh pipeline with an emphasis on the preservation of productive data, transactionality, and operation in Shadow Mode.

Experience with PostgreSQL transactions, migrations, and pipelines
I have extensive experience in developing and scaling high-load pipelines on Node.js / TypeScript and PostgreSQL.

Transactions and ACID: Practical experience with SERIALIZABLE / READ COMMITTED transaction isolation levels in Knex/TypeORM/Prisma/pg. Guarantee of complete rollback in case of failures and exclusion of race conditions.

Migrations: Writing reversible migrations (up/down) without downtime (zero-downtime migrations), safely adding unique constraints using CONCURRENTLY and data validation.

Ingestion & UPSERT: Implementation of tiered data collection pipelines (cron, worker pools, queues), transferring stale records to STALE via ON CONFLICT DO UPDATE with delta calculation without full matching with DELETE -> CREATE.

Answers to questions (Assessment & Conditions)
Fixed price for mandatory scope: $750

Separate cost for promotion mechanism (Optional): $200

Deadline: 7–9 working days (not including time for data accumulation in Shadow Mode on Staging).

Hour assessment:

Mandatory scope (1–9): ~38–44 hours.

Optional promotion: ~8–10 hours.

Total: ~46–54 hours.

When ready to start: Ready to begin work within 24 hours after agreeing on the technical specifications and gaining access to the repository/Staging.

Experience: Described above (Senior Full-stack / Backend Node.js/TS, PostgreSQL, Python integrations).

Questions before starting: Interaction format with the Python module: How is the module currently launched? Is it a CLI script (child_process.spawn / exec), a separate HTTP/gRPC microservice, or a wrapper around a subprocess?

Shadow report format (Audit Output): What is more preferable in the first iteration: adding columns to the existing admin table or exporting a CSV file via a service CLI/API?

Duplicate protection mechanism (Unique constraint): What composite key is planned to be used for the unique constraint in offers? (For example: (model_id, source, external_offer_id) or (slug, source, external_offer_id))?

ORM / Query Builder: Which library
Inclusion of services: Yes, the specified cost fully includes the preparation of DB migrations, deployment to Staging, conducting Smoke tests on 5 and 50 models, contract/rollback documentation, and 14 days (instead of the minimum of 7) of free bug fixes for this scope after delivery. Expand

Budget: 15000 UAH Deadline: 10 days

Hello! I can refine the existing pipeline without rewriting the system. I have experience with Node.js, TypeScript, PostgreSQL, Prisma, integrating external services, transactions, migrations, and building fault-tolerant logic. I will implement Shadow Mode, safe UPSERT/STALE, integration of a Python module, execution by slug/id, maintain the current production pipeline and cron, conduct staging/QA, prepare documentation, and provide support after launch.

Budget: 20000 UAH Deadline: 10 days

Hello! I work with Node.js/TypeScript and PostgreSQL, have experience with transactional updates, migrations, and ingestion pipelines — the task with UPSERT/STALE logic and integration of an external module through shadow mode is clear and familiar. To provide an accurate estimate, I need to look at the current schema of the offers table, the contract for the Python module output, and the volume of cron logic — I suggest we have a call, after which I will give a fixed price and an estimate in hours. I will evaluate the promotion mechanism as a separate amount after the main scope.

The cost includes staging, QA (smoke test + shadow run), migrations, and a 7-day bug-fix period.

Budget: 27000 UAH Deadline: 14 days

Hello!

I have worked as a backend developer, particularly with the NodeJS (TypeScript) + PostgreSQL stack, including raw SQL, transactions, and ETL. My main stack now is Python, so there will be no issues with the additional module. I have also implemented a seamless transition of production systems to a new approach, which will be useful for your old pipeline that needs to run continuously until the new one is activated.

1. Price for the mandatory scope: 65000 UAH
2. Promotion mechanism: 5000-7000 UAH
3. I will complete everything in 14-18 days (+7 days for bug fixes at the same rate)
4. In fact, this will take 100 hours
5. I am ready to start on Sunday

6. Experience with PostgreSQL transactions/migrations/ingestion:
I have worked with UPSERT logic, transactional updates of several related tables with rollback on errors, as well as with a cron-based ingestion pipeline (rolling batches, cooldown checks before external API calls) — that is, the patterns from your points 5 and 7 I have already implemented in practice multiple times.

7. Questions to clarify before starting:
• Regarding the legacy pipeline that needs to continue running in parallel — is there a description of its current logic (retry, error handling) somewhere?
• Current structure of the offers table — is there access to the schema/ER diagram before the code review?

8. Yes, staging, QA, and migration are included in the stated price. Bug fixes will be separate, as they can be hard to predict.

I would be happy to take on your project 🤗 Expand

Budget: 6716 UAH Deadline: 7 days

Good day. I read the technical specifications carefully; the task is clear and well-defined, and I will respond to all points.

Regarding the price: the fixed cost for the mandatory scope is $900-1300, with a timeframe of 7-10 working days, approximately 50-65 hours. The promotion mechanism, that is, transferring shadow values to production via slug or list without UI, I estimate separately: $150-250, plus 1-2 days to the overall timeframe. I can start within 2-3 days after gaining access to the repository and staging.

Regarding my experience with transactions and migrations: I have done a similar task using Django ORM and PostgreSQL, where it was necessary to normalize a denormalized CSV into relational tables, with 19,000 records of one type and 23,000 of another, through an idempotent bulk-import command, with pagination and duplicate checking. Additionally, there are 62 automated tests specifically around the correctness of the import and protection against partial or corrupted runs, which were run on CI against a live database. So the pattern of checking that a partial or failed run does not corrupt existing data is not new to me; I have already fine-tuned it manually.

What I would like to clarify before starting: How exactly is the Python module currently invoked—subprocess, a separate service with HTTP, or a queue? This significantly affects how to handle partial and failed runs at the Python-Node boundary. Is there currently any hint of a unique constraint format for offers, a natural key based on source and external_offer_id, or is this something I need to design from scratch? Is STALE a separate field or status on the offer, or is there already a similar mechanism in the schema that just needs to be expanded? For audit output, it will be easier to look at the current admin table to understand whether to add columns there or if it's simpler to create a separate CSV export script.

Regarding the last point: staging, QA, including a smoke test on 5 models and then shadow on about 50, migrations, and a 7-day bug-fix period—all of this is included in the stated price, and no additional payment is required.

I am ready to call if it is more convenient to discuss the details verbally rather than in text. Expand

Budget: 12000 UAH Deadline: 12 days

You need to refine the price refresh pipeline in Node.js and TypeScript so that new results are written to shadow fields and do not affect production until the end of QA.

I will start with code review and staging: I will look at the current cron, cooldown, and snapshot logic. I will connect the Python module as a separate component, leaving the validation of its result and writing to the database on the Node.js side. I will expand the offers table with the necessary fields and unique constraint, replacing DELETE and CREATE with UPSERT. I will set the STALE status only after a complete successful snapshot. I will update offers, selected offer, and shadow fields in one transaction with a full rollback in case of an error. I will not touch canonical fields; I will perform auditing in shadow columns or CSV.

I am ready to take on the mandatory scope with migrations, staging deployment, and contract documentation. Please write to discuss the estimate and timelines.

Budget: 5000 UAH Deadline: 3 days

I am a NextJs, React, NestJs developer. I am ready to take on this task.

Budget: 5000 UAH Deadline: 7 days

It's interesting to see such an order, rather than just a simple import or another fix of something on WordPress. The technical specification is very well composed: clear architecture, Shadow Mode, atomic transactions instead of DELETE / CREATE, and a clean Node.js/TS + Python stack.

We are a team of two people (Full-Stack / Backend) and have good experience with backend engineering, PostgreSQL migrations, and developing ingestion pipelines. We would be happy to work with you.

Budget: 17000 UAH Deadline: 12 days

Good day!

I have carefully reviewed the technical assignment.

I understand that a precise refinement of the existing pipeline is required without rewriting the backend: integration of a Python module into the existing Node.js/TypeScript service, implementation of Shadow Mode, UPSERT/STALE logic, PostgreSQL migrations, transactional data updates, triggering refresh by slug/id, as well as maintaining the current cron logic.

My estimate:
Mandatory scope — 14,000 UAH.
Promotion mechanism (separately) — 3,000 UAH.
Deadline — 12–14 days.
Estimated labor costs — about 60 hours.

The cost includes:
DB migrations;
work in staging;
smoke tests;
brief documentation on integrating Python → Node.js and rollback;
bug fixes within 7 days after delivery.
Before starting work, I would like to clarify a few points:
How does Node.js currently interact with the Python module (HTTP, CLI, subprocess, or another option)?
What library is used for PostgreSQL migrations?
Is there test access to the external API and staging database?
How well is the existing price refresh pipeline covered by tests?
I am ready to start working immediately after agreeing on the details and reviewing the codebase. Expand

Budget: 12000 UAH Deadline: 10 days

Good day, Evgeny!

Approach — targeted PR without rewriting the backend, starting with a limited code review and staging (production is untouched until Shadow QA is completed). Order: migrations (source, external_offer_id, last_seen_at, unique constraint for duplicates + shadow fields: price, selected offer ID, direct URL, status, risk/QA flags, checkedAt, engineVersion) → Python module adapter with explicit error/partial handling (partial never translates active offers to STALE) → replacing DELETE→CREATE with UPSERT + STALE strictly in one DB transaction with full rollback → canonical-safe: only offer/price/shadow are updated, brand/reference/model/slug/SEO are untouched → launch one slug and by list via CLI → audit: shadow columns in admin table or CSV → staging deploy, smoke on 5 models, Shadow Mode on ~50, documentation contract Python→Node + rollback procedure.

2. Budget: 12,000 UAH fixed for mandatory scope (promotion mechanics will be evaluated separately after code review).
3. Deadline: 10 days from access receipt.
4. Hour estimate: 25–30.
5. Ready to start immediately.
6. Experience: ingestion pipelines on Python/Node with PostgreSQL — transactional UPSERT updates, schema migrations, snapshot mechanics with statuses, deduplication by foreign keys; integrations Python→Node via subprocess/HTTP with structured error codes.
7. Questions before starting: how does the Python module currently return results (stdout/file/HTTP) and the format of the partial response; is there a natural key source+external_offer_id or do you prefer another candidate key; is staging a separate DB/schema and who applies migrations (PR or your CI).
8. Staging, QA, migrations, and 7+ days bug-fix after acceptance are included in the price.

For transparency: I prepare drafts of code/migrations with AI tools, check each line manually, and run them on staging. The price is below market — I am gathering initial reviews on the platform. Expand

Budget: 27000 UAH Deadline: 10 days

Hello! I will complete your task quickly and efficiently.

My recent works
https://indexfast.pro - fast website indexing
https://mono-bank.pp.ua - everything about Monobank
https://mamamia.pp.ua - online store
https://programist.pp.ua/ua/portfolio/ - portfolio of works
https://monitortest.pp.ua - monitor testing
https://keytest.pp.ua - keyboard testing
https://pctest.pp.ua - computer testing
https://devroman.dev/portfolio/ - portfolio
https://vseetut.matviy.pp.ua - layout
https://indexfast.pp.ua - fast website indexing

My portfolio: https://freelancehunt.com/ua/freelancer/romas6ka.html#portfolio
Write to me, I will start working today. I will be happy to collaborate with you! Expand

Budget: 14000 UAH Deadline: 8 days

Evgeny, what is needed here is not a general refactoring, but a safe integration of the new engine alongside production. I would immediately introduce a refresh run entity with a status of full/partial/failed: only a full snapshot can convert missing offers to STALE, and the recording of offers, selected metadata, and shadow fields occurs in a single transaction with rollback.

Relevant experience: Node.js/TypeScript services with PostgreSQL, queues and workers, Python/FastAPI integrations, migrations, and staged rollout. In my projects, I have implemented background ingestion processes, API contracts between components, retries, deduplication, and safe data updates without damaging the main catalog.

Estimated mandatory scope: 14,000 UAH, 8 calendar days, approximately 45-55 hours. The promotion mechanism separately: 3,000 UAH and 2 days. I am ready to start immediately after the code review.

The bid includes PR, migrations, Python → Node contract, UPSERT/STALE logic, launch by slug and list, staging deployment, smoke tests on 5 models, Shadow QA on 50 models, CSV or admin audit output, rollback documentation, and 7 days for bug fixes.

Before starting, I will clarify three things: how the Python module is currently called, which ORM and migration tool are used, whether there is a test copy of the production schema, and benchmark results for 5 models.

Budget: 6500 UAH Deadline: 1 day

Good day!

I have reviewed your task. I understand the scope of work and possible options for its implementation.

I would be happy to discuss the project details and propose an optimal solution.

Budget: 27000 UAH Deadline: 14 days

Good day. I am ready to start the targeted refinement of the existing pipeline, beginning with a limited code review and work in staging, without switching production until QA is complete.

A key technical nuance to consider from the outset: the recording of offers, selected metadata, and shadow fields must occur in a single transaction with an explicit snapshot status, so that in the case of a partial/failed run, nothing is transitioned to STALE and a full rollback is possible.

Briefly on the expected outcome: a PR with migrations, integration of Python to Node, shadow fields, UPSERT/STALE logic in the transaction, execution by a single slug and by a list, staging deploy, smoke runs, and brief documentation with rollback procedure. I will include support for fixes after acceptance.

Experience relevant to the task: extensive work with transactions and migrations in PostgreSQL during ingestion pipelines, implementation of UPSERT logic and safe snapshot mechanisms, practice in testing integrations on staging without access to production.

I need clarifying information before estimating and starting work:
1) how the Python module currently outputs results: standard output, file, HTTP, or RPC, and what possible error/partial responses look like;
2) which fields in the current offers table can be used for a reliable unique key or which candidate keys you prefer;
3) access to the database schema, test repository, and staging CI for preparing migrations and running smoke tests.

I include staging, migrations, QA runs, and the bug-fixing period for the implemented scope in the workflow.

Please send the sources for code review or a link to the repository and an example response from the Python module, and I will prepare a detailed estimate, fixed budget, and start plan. Expand

Budget: 1000 UAH Deadline: 1 day

Good day, I am ready to complete your task quickly and efficiently. I have extensive experience in creating various bots. Please write to me in private messages to discuss the details. I would be happy to help :)

Budget: 15000 UAH Deadline: 5 days

Evgeny, the task is clear: we need to integrate a Python validator into the current Node.js pipeline while maintaining the functionality of the legacy code through Shadow Mode. This will allow us to safely compare the results of the new module with the current logic before a full switch.

I will implement this through an intermediary layer that calls the Python script, parses the JSON response, and writes the data into separate tables in the PostgreSQL database. At the same time, I will add an endpoint to trigger processing of specific IDs from the list, which will simplify debugging and selective refresh.

What version of Python is used in the module, and are there any requirements for the interaction format between Node.js and Python, for example, through gRPC or just calling it as a process?